@exaudeus/workrail 0.6.1-beta.9 → 0.7.0

package/dist/application/services/workflow-service.js

@@ -54,8 +54,38 @@ class DefaultWorkflowService {
         if (enhancedContext._currentLoop) {
             const { loopId, loopStep } = enhancedContext._currentLoop;
             const loopContext = new loop_execution_context_1.LoopExecutionContext(loopId, loopStep.loop, enhancedContext._loopState?.[loopId]);
+            const bodyStep = this.loopStepResolver.resolveLoopBody(workflow, loopStep.body, loopStep.id);
+            const bodyIsCompleted = Array.isArray(bodyStep)
+                ? bodyStep.every(step => completed.includes(step.id))
+                : completed.includes(bodyStep.id);
+            if (bodyIsCompleted) {
+                loopContext.incrementIteration();
+                if (!enhancedContext._loopState) {
+                    enhancedContext._loopState = {};
+                }
+                enhancedContext._loopState[loopId] = loopContext.getCurrentState();
+                if (Array.isArray(bodyStep)) {
+                    bodyStep.forEach(step => {
+                        const index = completed.indexOf(step.id);
+                        if (index > -1) {
+                            completed.splice(index, 1);
+                        }
+                    });
+                }
+                else {
+                    const index = completed.indexOf(bodyStep.id);
+                    if (index > -1) {
+                        completed.splice(index, 1);
+                    }
+                }
+                if (!loopContext.shouldContinue(context)) {
+                    completed.push(loopId);
+                    delete enhancedContext._currentLoop;
+                    const nextStep = await this.getNextStep(workflow.id, completed, enhancedContext);
+                    return nextStep;
+                }
+            }
             if (loopContext.shouldContinue(context)) {
-                const bodyStep = this.loopStepResolver.resolveLoopBody(workflow, loopStep.body, loopStep.id);
                 if (!Array.isArray(bodyStep)) {
                     const isFirst = loopContext.isFirstIteration();
                     if (isFirst && loopContext.isEmpty(context)) {
@@ -83,25 +113,25 @@ class DefaultWorkflowService {
                     };
                 }
                 else {
+                    const isFirst = loopContext.isFirstIteration();
+                    if (isFirst && loopContext.isEmpty(context)) {
+                        const skipContext = context_optimizer_1.ContextOptimizer.createEnhancedContext(context, completed);
+                        delete skipContext._currentLoop;
+                        const nextStep = await this.getNextStep(workflow.id, completed, skipContext);
+                        return nextStep;
+                    }
+                    const useMinimal = !isFirst && !!this.loopContextOptimizer;
+                    const loopEnhancedContext = loopContext.injectVariables(context, useMinimal);
                     const uncompletedBodyStep = bodyStep.find(step => {
                         if (completed.includes(step.id)) {
                             return false;
                         }
                         if (step.runCondition) {
-                            return (0, condition_evaluator_1.evaluateCondition)(step.runCondition, context);
+                            return (0, condition_evaluator_1.evaluateCondition)(step.runCondition, loopEnhancedContext);
                         }
                         return true;
                     });
                     if (uncompletedBodyStep) {
-                        const isFirst = loopContext.isFirstIteration();
-                        if (isFirst && loopContext.isEmpty(context)) {
-                            const skipContext = context_optimizer_1.ContextOptimizer.createEnhancedContext(context, completed);
-                            delete skipContext._currentLoop;
-                            const nextStep = await this.getNextStep(workflow.id, completed, skipContext);
-                            return nextStep;
-                        }
-                        const useMinimal = !isFirst && !!this.loopContextOptimizer;
-                        const loopEnhancedContext = loopContext.injectVariables(context, useMinimal);
                         const optimizedContext = useMinimal && this.loopContextOptimizer
                             ? this.loopContextOptimizer.stripLoopMetadata(loopEnhancedContext)
                             : loopEnhancedContext;

package/dist/cli.js

@@ -1,5 +1,38 @@
 #!/usr/bin/env node
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -178,6 +211,17 @@ async function validateWorkflowFile(filePath) {
             console.error(chalk_1.default.yellow('\nPlease check the JSON syntax and try again.'));
             process.exit(1);
         }
+        const { validateWorkflow: schemaValidate } = await Promise.resolve().then(() => __importStar(require('./application/validation')));
+        const schemaResult = schemaValidate(workflow);
+        if (!schemaResult.valid) {
+            console.error(chalk_1.default.red('❌ Workflow validation failed:'), filePath);
+            console.error(chalk_1.default.yellow('\nValidation errors:'));
+            schemaResult.errors.forEach(error => {
+                console.error(chalk_1.default.red('  •'), error);
+            });
+            console.error(chalk_1.default.yellow('\nPlease fix the errors above and try again.'));
+            process.exit(1);
+        }
         const validationEngine = new validation_engine_1.ValidationEngine();
         const result = validationEngine.validateWorkflow(workflow);
         if (result.valid && !result.warnings?.length && !result.info?.length) {

package/dist/config/feature-flags.d.ts

@@ -0,0 +1,33 @@
+export interface FeatureFlagDefinition {
+    readonly key: string;
+    readonly envVar: string;
+    readonly defaultValue: boolean;
+    readonly description: string;
+    readonly since: string;
+    readonly stable: boolean;
+}
+export declare const FEATURE_FLAG_DEFINITIONS: ReadonlyArray<FeatureFlagDefinition>;
+export type FeatureFlagKey = typeof FEATURE_FLAG_DEFINITIONS[number]['key'];
+export type FeatureFlags = {
+    readonly [K in FeatureFlagKey]: boolean;
+};
+export interface IFeatureFlagProvider {
+    isEnabled(key: FeatureFlagKey): boolean;
+    getAll(): FeatureFlags;
+    getSummary(): string;
+}
+export declare class EnvironmentFeatureFlagProvider implements IFeatureFlagProvider {
+    private readonly flags;
+    constructor(env?: Record<string, string | undefined>);
+    isEnabled(key: FeatureFlagKey): boolean;
+    getAll(): FeatureFlags;
+    getSummary(): string;
+}
+export declare class StaticFeatureFlagProvider implements IFeatureFlagProvider {
+    private readonly flags;
+    constructor(flags?: Partial<FeatureFlags>);
+    isEnabled(key: FeatureFlagKey): boolean;
+    getAll(): FeatureFlags;
+    getSummary(): string;
+}
+export declare function createFeatureFlagProvider(env?: Record<string, string | undefined>): IFeatureFlagProvider;

package/dist/config/feature-flags.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticFeatureFlagProvider = exports.EnvironmentFeatureFlagProvider = exports.FEATURE_FLAG_DEFINITIONS = void 0;
+exports.createFeatureFlagProvider = createFeatureFlagProvider;
+exports.FEATURE_FLAG_DEFINITIONS = [
+    {
+        key: 'sessionTools',
+        envVar: 'WORKRAIL_ENABLE_SESSION_TOOLS',
+        defaultValue: false,
+        description: 'Enable session management tools (workrail_create_session, workrail_update_session, etc.) and HTTP dashboard server',
+        since: '0.6.0',
+        stable: false,
+    },
+    {
+        key: 'experimentalWorkflows',
+        envVar: 'WORKRAIL_ENABLE_EXPERIMENTAL_WORKFLOWS',
+        defaultValue: false,
+        description: 'Load workflows from experimental/ directory',
+        since: '0.6.1',
+        stable: false,
+    },
+    {
+        key: 'verboseLogging',
+        envVar: 'WORKRAIL_VERBOSE_LOGGING',
+        defaultValue: false,
+        description: 'Enable detailed debug logging',
+        since: '0.6.0',
+        stable: true,
+    },
+];
+function parseBoolean(value, defaultValue) {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    const normalized = value.toLowerCase().trim();
+    const truthyValues = ['true', '1', 'yes', 'on'];
+    const falsyValues = ['false', '0', 'no', 'off'];
+    if (truthyValues.includes(normalized)) {
+        return true;
+    }
+    if (falsyValues.includes(normalized)) {
+        return false;
+    }
+    console.warn(`[FeatureFlags] Invalid boolean value "${value}" for flag. ` +
+        `Expected one of: ${[...truthyValues, ...falsyValues].join(', ')}. ` +
+        `Using default: ${defaultValue}`);
+    return defaultValue;
+}
+class EnvironmentFeatureFlagProvider {
+    constructor(env = process.env) {
+        const flags = {};
+        for (const definition of exports.FEATURE_FLAG_DEFINITIONS) {
+            const envValue = env[definition.envVar];
+            flags[definition.key] = parseBoolean(envValue, definition.defaultValue);
+        }
+        this.flags = flags;
+        const enabledExperimental = exports.FEATURE_FLAG_DEFINITIONS
+            .filter(def => !def.stable && this.flags[def.key])
+            .map(def => def.key);
+        if (enabledExperimental.length > 0) {
+            console.error(`[FeatureFlags] Experimental features enabled: ${enabledExperimental.join(', ')}`);
+        }
+    }
+    isEnabled(key) {
+        return this.flags[key] ?? false;
+    }
+    getAll() {
+        return { ...this.flags };
+    }
+    getSummary() {
+        const lines = ['Feature Flags:'];
+        for (const definition of exports.FEATURE_FLAG_DEFINITIONS) {
+            const enabled = this.flags[definition.key];
+            const status = enabled ? '✓ ENABLED' : '✗ DISABLED';
+            const stability = definition.stable ? '[STABLE]' : '[EXPERIMENTAL]';
+            lines.push(`  ${status} ${stability} ${definition.key}`);
+            lines.push(`    ${definition.description}`);
+            lines.push(`    env: ${definition.envVar}`);
+        }
+        return lines.join('\n');
+    }
+}
+exports.EnvironmentFeatureFlagProvider = EnvironmentFeatureFlagProvider;
+class StaticFeatureFlagProvider {
+    constructor(flags = {}) {
+        this.flags = flags;
+    }
+    isEnabled(key) {
+        return this.flags[key] ?? false;
+    }
+    getAll() {
+        const allFlags = {};
+        for (const definition of exports.FEATURE_FLAG_DEFINITIONS) {
+            allFlags[definition.key] =
+                this.flags[definition.key] ?? definition.defaultValue;
+        }
+        return allFlags;
+    }
+    getSummary() {
+        return JSON.stringify(this.getAll(), null, 2);
+    }
+}
+exports.StaticFeatureFlagProvider = StaticFeatureFlagProvider;
+function createFeatureFlagProvider(env) {
+    return new EnvironmentFeatureFlagProvider(env);
+}

package/dist/container.d.ts

@@ -3,7 +3,9 @@ import { ValidationEngine } from './application/services/validation-engine.js';
 import { IWorkflowStorage } from './types/storage.js';
 import { WorkflowLookupServer } from './types/server.js';
 import { ILoopContextOptimizer } from './types/loop-context-optimizer.js';
+import { IFeatureFlagProvider } from './config/feature-flags.js';
 export interface AppContainer {
+    featureFlags: IFeatureFlagProvider;
     storage: IWorkflowStorage;
     validationEngine: ValidationEngine;
     loopContextOptimizer: ILoopContextOptimizer;

package/dist/container.js

@@ -6,13 +6,16 @@ const workflow_service_js_1 = require("./application/services/workflow-service.j
 const validation_engine_js_1 = require("./application/services/validation-engine.js");
 const server_js_1 = require("./infrastructure/rpc/server.js");
 const loop_context_optimizer_js_1 = require("./application/services/loop-context-optimizer.js");
+const feature_flags_js_1 = require("./config/feature-flags.js");
 function createAppContainer(overrides = {}) {
+    const featureFlags = overrides.featureFlags ?? (0, feature_flags_js_1.createFeatureFlagProvider)();
     const storage = overrides.storage ?? (0, storage_js_1.createDefaultWorkflowStorage)();
     const validationEngine = overrides.validationEngine ?? new validation_engine_js_1.ValidationEngine();
     const loopContextOptimizer = overrides.loopContextOptimizer ?? new loop_context_optimizer_js_1.LoopContextOptimizer();
     const workflowService = overrides.workflowService ?? new workflow_service_js_1.DefaultWorkflowService(storage, validationEngine, loopContextOptimizer);
     const server = overrides.server ?? (0, server_js_1.createWorkflowLookupServer)(workflowService);
     return {
+        featureFlags,
         storage,
         validationEngine,
         loopContextOptimizer,

package/dist/mcp-server.js

@@ -38,19 +38,44 @@ const container_js_1 = require("./container.js");
 const index_js_1 = require("./infrastructure/session/index.js");
 const session_tools_js_1 = require("./tools/session-tools.js");
 class WorkflowOrchestrationServer {
-    constructor() {
-        this.container = (0, container_js_1.createAppContainer)();
-        this.sessionManager = new index_js_1.SessionManager();
-        this.httpServer = new index_js_1.HttpServer(this.sessionManager, { autoOpen: false });
-        this.sessionTools = (0, session_tools_js_1.createSessionTools)(this.sessionManager, this.httpServer);
+    constructor(container) {
+        this.sessionManager = null;
+        this.httpServer = null;
+        this.container = container ?? (0, container_js_1.createAppContainer)();
+        this.featureFlags = this.container.featureFlags;
+        if (this.featureFlags.isEnabled('sessionTools')) {
+            this.sessionManager = new index_js_1.SessionManager();
+            this.httpServer = new index_js_1.HttpServer(this.sessionManager, { autoOpen: false });
+            this.sessionTools = (0, session_tools_js_1.createSessionTools)(this.sessionManager, this.httpServer);
+            console.error('[FeatureFlags] Session tools enabled');
+        }
+        else {
+            this.sessionTools = [];
+            console.error('[FeatureFlags] Session tools disabled (enable with WORKRAIL_ENABLE_SESSION_TOOLS=true)');
+        }
     }
     async initialize() {
-        await this.httpServer.start();
+        if (this.featureFlags.isEnabled('sessionTools') && this.httpServer) {
+            await this.httpServer.start();
+            console.error('[FeatureFlags] Dashboard server started');
+        }
     }
     getSessionTools() {
         return this.sessionTools;
     }
     async handleSessionTool(name, args) {
+        if (!this.featureFlags.isEnabled('sessionTools') || !this.sessionManager || !this.httpServer) {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            error: 'Session tools are not enabled. Set WORKRAIL_ENABLE_SESSION_TOOLS=true to enable.',
+                            tool: name
+                        }, null, 2)
+                    }],
+                isError: true
+            };
+        }
         return (0, session_tools_js_1.handleSessionTool)(name, args, this.sessionManager, this.httpServer);
     }
     async callWorkflowMethod(method, params) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "0.6.1-beta.9",
+  "version": "0.7.0",
   "description": "MCP server for structured workflow orchestration and step-by-step task guidance",
   "license": "MIT",
   "bin": {