thiagomvas/FFlow

FFlow is a .NET workflow orchestration engine that enables developers to define, execute, and monitor automated processes. It provides a fluent API for constructing workflows with support for conditional branching, parallel execution, and error handling. The system includes built-in steps for common operations such as HTTP requests, file I/O, shell commands, and .NET CLI interactions. Additionally, it offers scheduling capabilities, observability metrics, and automatic dependency injection integration.

The FFlow.Samples.BasicServer sample project has been added, providing a complete example of a .NET web application that exposes webhook endpoints for triggering workflows. The sample includes three distinct workflow implementations: BuildAndTestWorkflow, which clones a repository and runs tests; BuildArtifactsWorkflow, which builds and packages artifacts; and ExampleWebhook, a simple demonstration. The server also exposes a /metrics endpoint for monitoring and integrates with the FFlow dependency injection and observability systems.

samples · high confidence

Users can now connect to, upload, download, create, delete, and rename files and directories on an SFTP server directly within workflows. The update introduces new steps for connecting to and disconnecting from SFTP servers, as well as steps for uploading and downloading single files and entire directories (including recursive operations), creating and deleting directories, deleting single files, and renaming files. These steps are exposed via the \IWorkflowBuilderExtensions\ for easy integration into existing workflows.

src/FFlow.Steps.SFTP · high confidence

The FFlow.Demo project now includes several new demo components: HelloStep and GoodByeStep for basic workflow execution, a LoggerStepDecorator for logging step execution, a NoOpStep demonstrating graph description capabilities, and two workflow definitions (HelloWorkflow and TestWorkflow) that showcase configuration and metrics integration. Additionally, Program.cs provides a concrete example of building and running a workflow using the FileChecksum step.

src/FFlow.Demo · high confidence

Users can now execute shell commands and scripts directly within workflows using the new RunCommand, RunScriptRaw, and RunScriptFile extension methods. The RunCommand step executes a specified command with optional arguments, working directory, and environment variables. The RunScriptRaw step allows executing raw script content, while RunScriptFile executes scripts loaded from a file path. Both steps support context injection via the {context:Key} syntax, enabling dynamic values to be substituted into commands and scripts. The exit code of the executed process is now set as the step's output, and empty output lines are no longer logged to the output handler.

src/FFlow.Steps.Shell · high confidence

Users can now generate visual representations of workflow definitions. A new \IDescribableStep\ interface allows steps to provide custom graph structures, while the \WorkflowGraph\ class and its \Describe()\ extension method traverse the workflow to build a graph of nodes and edges. The output supports multiple formats, including Mermaid and DOT graph languages, with configuration flags to filter out input/output setters and silent steps.

src/FFlow/Visualization · high confidence

The FFlow.Validation library now provides built-in steps to enforce data integrity within workflows. Users can ensure required keys exist in the context (RequireKey/RequireKeys), verify that values are not null (RequireNotNull), check that strings or collections are not empty (RequireNotEmpty), and validate values against a regular expression pattern (RequireRegex). Additionally, a ValidatorDecorator automatically applies validation attributes to workflow steps, and all validation errors now throw a specific FlowValidationException rather than generic exceptions.

src/FFlow.Validation · high confidence

The FFlow library now includes a new RetryPolicies component that provides three strategies for handling transient failures in workflows: fixed delay, exception-type filtering, and exponential backoff. Users can now configure retry behavior with specific delays or dynamic backoff intervals to improve workflow resilience.

src/FFlow/RetryPolicies · high confidence

The DI extension now automatically scans assemblies for types implementing IFlowStep, IWorkflowDefinition, and the concrete FlowStep base class. It registers each discovered step and workflow type as transient services, including the interface-to-implementation mappings and a factory for building workflows, enabling automatic service registration without manual configuration.

src/FFlow.Extensions.Microsoft.DependencyInjection · high confidence

The repository has been reorganized into a modular solution with a src/ and tests/ directory structure, establishing separate projects for core functionality, CLI, and step extensions (e.g., FFlow.Core, FFlow.Cli, FFlow.Steps.\*). A new docfx configuration and documentation site structure have been added, alongside standard repository files like a Code of Conduct, Contributing guidelines, and an MIT License.

(repo-wide) · high confidence

The FFlow.Core library introduces several new capabilities for workflow and step management. Users can now configure step execution with retry policies (IRetryPolicy), conditional skipping (ISkippableStep), and compensation logic (ICompensableStep). A new base class (FlowStep) and decorator (BaseStepDecorator) simplify step implementation, while the context (IFlowContext) gains methods to store and retrieve inputs, outputs, and arbitrary values. Workflow definitions can now register and retrieve step templates via IStepTemplateRegistry, and workflows support global error handlers, finalizers, and graceful stopping. Additionally, attributes (StepNameAttribute, StepTagsAttribute, SilentStepAttribute) allow attaching metadata to steps, and the ForkStrategy enum controls parallel step execution behavior.

src/FFlow.Core · high confidence

The FFlow CLI tool is now available in the src/FFlow.Cli directory, providing three main commands: 'init' to scaffold new workflow projects (with interactive or non-interactive modes), 'run' to execute C\# scripts inside a .NET 10 SDK Docker container, and 'doctor' to check environment dependencies like Docker and .NET SDK. The CLI uses a custom command dispatcher and builder pattern, with help text and templates for project generation.

src/FFlow.Cli · high confidence

Users can now add HTTP requests (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS) to their workflows using the new \HttpRequestStep\ and corresponding extension methods on \WorkflowBuilderBase\. The step supports configuring the URL, HTTP method, headers, body, timeout, and acceptable status codes, and allows passing query parameters and content type for the request.

src/FFlow.Steps.Http · high confidence

FFlow now supports pluggable metrics collection through the new IMetricsSink interface, allowing users to attach custom or in-memory sinks to track workflow and step events. The framework provides default listeners (MetricTrackingListener, ConsoleFlowEventListener, TimelineRecorder) and a NoOpMetricsSink for disabling metrics. Users can register a metrics sink via FFlowBuilder.UseMetrics() and retrieve it from the IFlowContext. The MetricsSnapshot class captures counters, timings, and gauges for debugging or testing.

src/FFlow.Observability · high confidence

Users can now schedule workflows to run at specific times, recurring intervals, or via cron expressions. The new \FFlowScheduleRunner\ background service polls for due workflows and executes them, supporting both in-memory and file-based persistence via \InMemoryFlowScheduleStore\ and \FileFlowScheduleStore\. Configuration is handled through \FFlowScheduleRunnerOptions\ and the \IFlowSchedulingBuilder\ extension methods.

src/FFlow.Scheduling · high confidence

The FFlow library now provides a complete workflow execution engine. Users can construct workflows using the \FFlowBuilder\ and its extension methods (\StartWith\, \Then\) to define step sequences. The \Workflow\ class manages execution, including support for global error handlers, finalizers, and step timeouts. The update also introduces a \CompositeFlowEventListener\ to aggregate multiple event listeners, a \PipelineLoggerEventListener\ for console-based logging, and an \InMemoryFFLowContext\ to store inputs, outputs, and single values between steps. Additionally, a \StepTemplateRegistry\ allows for reusable step configurations, and a \SwitchCaseBuilder\ enables conditional branching within workflows.

src/FFlow · high confidence

Users can now execute common .NET CLI commands directly within workflows. This change introduces new step types for dotnet build, run, test, pack, publish, restore, clean, and NuGet push, each exposing relevant CLI options (e.g., configuration, framework, verbosity) and returning structured results (exit code, output, error, and for tests, pass/fail/skipped counts). The steps are configured via explicit properties rather than global context, and each step populates a corresponding result object (e.g., DotnetBuildResult, DotnetTestResult) on the workflow context.

src/FFlow.Steps.DotNet · high confidence

The library introduces a suite of new built-in steps to enhance workflow composition and control. These include branching logic with IfStep and SwitchStep, iteration with ForEachStep, parallel execution with ForkStep, and conditional execution control via StopExecutionIfStep and ThrowExceptionIfStep. Additional utility steps allow for setting inputs and outputs (InputSetterStep, OutputSetterStep), logging to the console (LogToConsoleStep), and delegating to other workflows (BuilderStep, WorkflowContinuationStep). The existing DelegateFlowStep has been refactored to inherit from FlowStep and apply consistent metadata attributes.

src/FFlow/Steps · high confidence

The FFlow library now provides new extension methods to simplify common operations. For IFlowContext, you can now load environment variables directly into the context, retrieve or set a unique context ID, identify the root context, and access registered event listeners. For IWorkflowMetadataStore, convenience methods (Set/Get/TryGet/Has) are available for the 'name' and 'description' metadata fields, allowing for easier metadata management.

src/FFlow/Extensions · high confidence

Added a comprehensive set of workflow steps for file and directory operations, including reading and writing text and binary content, computing file checksums, and managing file/directory existence, creation, deletion, moving, copying, and renaming. These new steps allow users to perform common file system tasks directly within their workflows, with support for context storage and configurable behaviors like appending to files or overwriting destinations.

src/FFlow.Steps.FileIO · high confidence

Added new validation attributes—RequireKey, RequireNotNull, RequireRegex, and NotEmpty—that allow users to enforce constraints on flow context keys. Each attribute implements BaseFlowValidationAttribute and returns a corresponding validation step (HasKeyStep, NotNullStep, RegexPatternStep, or NotEmptyStep), enabling declarative validation of key existence, null status, and pattern matching within the flow.

src/FFlow.Validation/Annotations · medium confidence

The source generator in the FFlow.Steps.DotNet.SourceGenerators project has been implemented to automatically generate C\# code for workflow steps. Specifically, it creates extension methods on \WorkflowBuilderBase\ to add steps to a workflow, and extension methods on \IFlowContext\ to retrieve step outputs. This enables developers to use a fluent API for building workflows without writing boilerplate code manually.

src/FFlow.Steps.DotNet.SourceGenerators · medium confidence

The CI/CD pipeline definitions for running tests and pushing to NuGet have been rewritten in the FFlow domain-specific language. The new pipelines use the FFlow builder pattern to orchestrate .NET build, test, and pack steps, replacing the previous configuration. This change updates how the test and deployment workflows are defined and executed within the pipelines directory.

pipelines · high confidence

The FFlow library introduces several internal components to support workflow execution and error handling. A new StepCreationException is thrown when a step cannot be instantiated due to missing dependency injection registration or lack of a parameterless constructor, providing clearer diagnostics. The Internals class now generates standardized keys for input, output, and event listeners within the flow context. Additionally, a custom ReversibleQueue\<T\> replaces previous list-based iteration to allow backtracking through steps, and an internal SwitchCase record is added to represent conditional branches.

src/FFlow/Internals · high confidence

The legacy interfaces IFlowContext, IFlowStep, IWorkflow, IWorkflowBuilder, and IWorkflowDefinition have been removed from the core library, along with the FFlowBuilder implementation and the InMemoryFFLowContext. This eliminates the previous builder pattern for defining and executing workflows, indicating a shift in how workflows are constructed and run within the FFlow framework.

src/FFlow/FFlow, src/FFlow/FFlow.Core, src/FFlow/FFlow.Demo · high confidence

Added comprehensive test coverage for workflow execution, dependency injection, and step behaviors; Added shared test infrastructure for workflow testing; Added tests for automatic assembly discovery in DI registration; Added unit tests for the HTTP request step; Added unit tests for validation step attributes.

The FFlow workflow engine and its extensions have been updated to version 1.2.3, targeting .NET 9. This release introduces new capabilities including cron-based scheduling, HTTP and SFTP steps, file I/O operations, and source generators for .NET CLI interactions. The project structure has been reorganized, moving the CLI to a dedicated package, consolidating observability and validation modules, and updating test projects to use .NET 9 and NUnit 4.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 56 → 56 (-0.4)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 81 → 74 (-7.7)
• Architecture 80 → 81 (+0.2)
• Maturity 75 → 75 (+0.1)
• Readiness 50 → 47 (-2.6)
• Security 57 → 65 (+7.5)
• Performance 56 → 57 (+0.4)

• Bounded contexts not declared
• Change coupling clique: DotnetBuildStep.cs, DotnetRestoreStep.cs, DotnetTestStep.cs (src/FFlow.Steps.DotNet/DotnetBuildStep.cs)
• Change coupling: HelloStep.cs ↔ Program.cs (src/FFlow.Demo/HelloStep.cs)
• Change coupling: HelloWorkflow.cs ↔ Program.cs (src/FFlow.Demo/HelloWorkflow.cs)
• Duplicated block (10 lines × 2) (src/FFlow.Steps.DotNet.SourceGenerators/IFlowContextExtensionGenerator.cs)
• Duplicated block (13 lines × 2) (src/FFlow.Cli/Commands/RunCommand.cs)
• Duplicated block (15 lines × 2) (src/FFlow.Steps.DotNet/Internals.cs)
• Duplicated block (15 lines × 2) (src/FFlow/FFlowBuilderStepConfigurationExtensions.cs)
• Duplicated block (23 lines × 2) (src/FFlow.Steps.Shell/RunCommandStep.cs)
• Duplicated block (5 lines × 2) (src/FFlow.Steps.DotNet/DotnetBuildStep.cs)
• Duplicated block (6 lines × 2) (src/FFlow.Steps.DotNet/DotnetBuildStep.cs)
• Duplicated block (6 lines × 2) (src/FFlow.Steps.DotNet/DotnetPackStep.cs)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Monorepo: only 1 of 2 solutions was scored
• …and 5 more

• Base-context workflow trigger runs with an unscoped token
• CRAP 34: HttpRequestStep.ExecuteAsync (src/FFlow.Steps.Http/HttpRequestStep.cs)
• Documentation: hard to navigate (docs/features/events.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (src/FFlow.Steps.DotNet.SourceGenerators/IFlowContextExtensionGenerator.cs)
• Duplicated block (14 lines × 2) (src/FFlow.Cli/Commands/RunCommand.cs)
• Duplicated block (16 lines × 2) (src/FFlow/FFlowBuilderStepConfigurationExtensions.cs)
• Duplicated block (25 lines × 2) (src/FFlow.Validation/NotEmptyStep.cs)
• Duplicated block (34 lines × 2) (src/FFlow.Steps.DotNet/Internals.cs)
• Duplicated block (40 lines × 2) (src/FFlow.Steps.Shell/RunCommandStep.cs)
• Duplicated block (5 lines × 2) (src/FFlow.Steps.DotNet/DotnetBuildStep.cs)
• Duplicated block (5 lines × 2) (src/FFlow/Steps/ForkStep.cs)
• Duplicated block (6 lines × 2) (src/FFlow.Steps.DotNet/DotnetBuildStep.cs)
• Duplicated block (7 lines × 2) (src/FFlow.Steps.DotNet/DotnetPackStep.cs)
• Edited copy of a member (40 corresponding lines) (src/FFlow.Steps.Shell/RunCommandStep.cs)
• End-of-life runtime: .NET net9.0
• High CVE: SSH.NET 2025.0.0
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 45 more

• Unchanged — 4 HTTP endpoints

• Unchanged — 2 containers · 0 contexts · 0 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

thiagomvas/FFlow was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.