griptape-nodes 0.44.0__py3-none-any.whl → 0.45.1__py3-none-any.whl

griptape_nodes/retained_mode/managers/workflow_manager.py

@@ -45,6 +45,12 @@ from griptape_nodes.retained_mode.events.library_events import (
 )
 from griptape_nodes.retained_mode.events.object_events import ClearAllObjectStateRequest
 from griptape_nodes.retained_mode.events.workflow_events import (
+    BranchWorkflowRequest,
+    BranchWorkflowResultFailure,
+    BranchWorkflowResultSuccess,
+    CompareWorkflowsRequest,
+    CompareWorkflowsResultFailure,
+    CompareWorkflowsResultSuccess,
     DeleteWorkflowRequest,
     DeleteWorkflowResultFailure,
     DeleteWorkflowResultSuccess,
@@ -57,14 +63,27 @@ from griptape_nodes.retained_mode.events.workflow_events import (
     LoadWorkflowMetadata,
     LoadWorkflowMetadataResultFailure,
     LoadWorkflowMetadataResultSuccess,
+    MergeWorkflowBranchRequest,
+    MergeWorkflowBranchResultFailure,
+    MergeWorkflowBranchResultSuccess,
+    MoveWorkflowRequest,
+    MoveWorkflowResultFailure,
+    MoveWorkflowResultSuccess,
     PublishWorkflowRequest,
     PublishWorkflowResultFailure,
+    PublishWorkflowResultSuccess,
     RegisterWorkflowRequest,
     RegisterWorkflowResultFailure,
     RegisterWorkflowResultSuccess,
+    RegisterWorkflowsFromConfigRequest,
+    RegisterWorkflowsFromConfigResultFailure,
+    RegisterWorkflowsFromConfigResultSuccess,
     RenameWorkflowRequest,
     RenameWorkflowResultFailure,
     RenameWorkflowResultSuccess,
+    ResetWorkflowBranchRequest,
+    ResetWorkflowBranchResultFailure,
+    ResetWorkflowBranchResultSuccess,
     RunWorkflowFromRegistryRequest,
     RunWorkflowFromRegistryResultFailure,
     RunWorkflowFromRegistryResultSuccess,
@@ -101,6 +120,13 @@ T = TypeVar("T")
 logger = logging.getLogger("griptape_nodes")
 
 
+class WorkflowRegistrationResult(NamedTuple):
+    """Result of processing workflows for registration."""
+
+    succeeded: list[str]
+    failed: list[str]
+
+
 class WorkflowManager:
     WORKFLOW_METADATA_HEADER: ClassVar[str] = "script"
     MAX_MINOR_VERSION_DEVIATION: ClassVar[int] = (
@@ -227,6 +253,10 @@ class WorkflowManager:
             RenameWorkflowRequest,
             self.on_rename_workflow_request,
         )
+        event_manager.assign_manager_to_request_type(
+            MoveWorkflowRequest,
+            self.on_move_workflow_request,
+        )
 
         event_manager.assign_manager_to_request_type(
             SaveWorkflowRequest,
@@ -241,6 +271,26 @@ class WorkflowManager:
             ImportWorkflowAsReferencedSubFlowRequest,
             self.on_import_workflow_as_referenced_sub_flow_request,
         )
+        event_manager.assign_manager_to_request_type(
+            BranchWorkflowRequest,
+            self.on_branch_workflow_request,
+        )
+        event_manager.assign_manager_to_request_type(
+            MergeWorkflowBranchRequest,
+            self.on_merge_workflow_branch_request,
+        )
+        event_manager.assign_manager_to_request_type(
+            ResetWorkflowBranchRequest,
+            self.on_reset_workflow_branch_request,
+        )
+        event_manager.assign_manager_to_request_type(
+            CompareWorkflowsRequest,
+            self.on_compare_workflows_request,
+        )
+        event_manager.assign_manager_to_request_type(
+            RegisterWorkflowsFromConfigRequest,
+            self.on_register_workflows_from_config_request,
+        )
 
     def has_current_referenced_workflow(self) -> bool:
         """Check if there is currently a referenced workflow context active."""
@@ -258,7 +308,15 @@ class WorkflowManager:
         # All of the libraries have loaded, and any workflows they came with have been registered.
         # See if there are USER workflow JSONs to load.
         default_workflow_section = "app_events.on_app_initialization_complete.workflows_to_register"
-        self.register_workflows_from_config(config_section=default_workflow_section)
+
+        # Use the request/response pattern for workflow registration
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        register_request = RegisterWorkflowsFromConfigRequest(config_section=default_workflow_section)
+        register_result = GriptapeNodes.handle_request(register_request)
+
+        if not isinstance(register_result, RegisterWorkflowsFromConfigResultSuccess):
+            logger.warning("Failed to register workflows from configuration during library initialization")
 
         # Print it all out nicely.
         self.print_workflow_load_status()
@@ -611,6 +669,82 @@ class WorkflowManager:
 
         return RenameWorkflowResultSuccess()
 
+    def on_move_workflow_request(self, request: MoveWorkflowRequest) -> ResultPayload:  # noqa: PLR0911
+        try:
+            # Validate source workflow exists
+            workflow = WorkflowRegistry.get_workflow_by_name(request.workflow_name)
+        except KeyError:
+            logger.error("Failed to move workflow '%s' because it does not exist", request.workflow_name)
+            return MoveWorkflowResultFailure()
+
+        config_manager = GriptapeNodes.ConfigManager()
+
+        # Get current file path
+        current_file_path = WorkflowRegistry.get_complete_file_path(workflow.file_path)
+        if not Path(current_file_path).exists():
+            logger.error(
+                "Failed to move workflow '%s': File path '%s' does not exist", request.workflow_name, current_file_path
+            )
+            return MoveWorkflowResultFailure()
+
+        # Clean and validate target directory
+        target_directory = request.target_directory.strip().replace("\\", "/")
+        target_directory = target_directory.removeprefix("/")  # Remove leading slash
+
+        # Create target directory path
+        target_dir_path = config_manager.workspace_path / target_directory
+
+        try:
+            # Create target directory if it doesn't exist
+            target_dir_path.mkdir(parents=True, exist_ok=True)
+        except OSError as e:
+            logger.error("Failed to create target directory '%s': %s", target_dir_path, str(e))
+            return MoveWorkflowResultFailure()
+
+        # Create new file path
+        workflow_filename = Path(workflow.file_path).name
+        new_relative_path = str(Path(target_directory) / workflow_filename)
+        new_absolute_path = config_manager.workspace_path / new_relative_path
+
+        # Check if target file already exists
+        if new_absolute_path.exists():
+            logger.error(
+                "Failed to move workflow '%s': Target file '%s' already exists",
+                request.workflow_name,
+                new_absolute_path,
+            )
+            return MoveWorkflowResultFailure()
+
+        try:
+            # Move the file
+            Path(current_file_path).rename(new_absolute_path)
+
+            # Update workflow registry with new file path
+            workflow.file_path = new_relative_path
+
+            # Update configuration - remove old path and add new path
+            config_manager.delete_user_workflow(workflow.file_path)
+            config_manager.save_user_workflow_json(str(new_absolute_path))
+
+        except OSError as e:
+            logger.error("Failed to move workflow file '%s' to '%s': %s", current_file_path, new_absolute_path, str(e))
+
+            # Attempt to rollback if file was moved but registry update failed
+            if new_absolute_path.exists() and not Path(current_file_path).exists():
+                try:
+                    new_absolute_path.rename(current_file_path)
+                    logger.info("Rolled back file move for workflow '%s'", request.workflow_name)
+                except OSError:
+                    logger.error("Failed to rollback file move for workflow '%s'", request.workflow_name)
+
+            return MoveWorkflowResultFailure()
+        except Exception as e:
+            logger.error("Failed to move workflow '%s': %s", request.workflow_name, str(e))
+            return MoveWorkflowResultFailure()
+        else:
+            logger.info("Successfully moved workflow '%s' to '%s'", request.workflow_name, new_relative_path)
+            return MoveWorkflowResultSuccess(moved_file_path=new_relative_path)
+
     def on_load_workflow_metadata_request(  # noqa: C901, PLR0912, PLR0915
         self, request: LoadWorkflowMetadata
     ) -> ResultPayload:
@@ -933,7 +1067,12 @@ class WorkflowManager:
         return import_statements
 
     def _generate_workflow_file_contents_and_metadata(  # noqa: C901, PLR0912, PLR0915
-        self, file_name: str, creation_date: datetime, image_path: str | None = None
+        self,
+        file_name: str,
+        creation_date: datetime,
+        image_path: str | None = None,
+        prior_workflow: Workflow | None = None,
+        custom_metadata: WorkflowMetadata | None = None,
     ) -> tuple[str, WorkflowMetadata]:
         """Generate the contents of a workflow file.
 
@@ -941,6 +1080,10 @@ class WorkflowManager:
             file_name: The name of the workflow file
             creation_date: The creation date for the workflow
             image_path: Optional; the path to an image to include in the workflow metadata
+            prior_workflow: Optional; existing workflow to preserve branch info from
+            custom_metadata: Optional; pre-constructed metadata to use instead of generating it
+                           from the current workflow state. When provided, this metadata will be
+                           used directly, allowing branch/merge operations to pass specific metadata.
 
         Returns:
             A tuple of (workflow_file_contents, workflow_metadata)
@@ -989,22 +1132,27 @@ class WorkflowManager:
             raise TypeError(details)
         serialized_flow_commands = serialized_flow_result.serialized_flow_commands
 
-        # Create the Workflow Metadata header.
-        workflows_referenced = None
-        if serialized_flow_commands.referenced_workflows:
-            workflows_referenced = list(serialized_flow_commands.referenced_workflows)
-
-        workflow_metadata = self._generate_workflow_metadata(
-            file_name=file_name,
-            engine_version=engine_version,
-            creation_date=creation_date,
-            node_libraries_referenced=list(serialized_flow_commands.node_libraries_used),
-            workflows_referenced=workflows_referenced,
-        )
-        if workflow_metadata is None:
-            details = f"Failed to generate metadata for workflow '{file_name}'."
-            logger.error(details)
-            raise ValueError(details)
+        # Use custom metadata if provided, otherwise generate it
+        if custom_metadata is not None:
+            workflow_metadata = custom_metadata
+        else:
+            # Create the Workflow Metadata header.
+            workflows_referenced = None
+            if serialized_flow_commands.referenced_workflows:
+                workflows_referenced = list(serialized_flow_commands.referenced_workflows)
+
+            workflow_metadata = self._generate_workflow_metadata(
+                file_name=file_name,
+                engine_version=engine_version,
+                creation_date=creation_date,
+                node_libraries_referenced=list(serialized_flow_commands.node_libraries_used),
+                workflows_referenced=workflows_referenced,
+                prior_workflow=prior_workflow,
+            )
+            if workflow_metadata is None:
+                details = f"Failed to generate metadata for workflow '{file_name}'."
+                logger.error(details)
+                raise ValueError(details)
 
         # Set the image if provided
         if image_path:
@@ -1143,8 +1291,6 @@ class WorkflowManager:
         return final_code_output, workflow_metadata
 
     def on_save_workflow_request(self, request: SaveWorkflowRequest) -> ResultPayload:  # noqa: C901, PLR0912, PLR0915
-        local_tz = datetime.now().astimezone().tzinfo
-
         # Start with the file name provided; we may change it.
         file_name = request.file_name
 
@@ -1156,10 +1302,19 @@ class WorkflowManager:
             prior_workflow = WorkflowRegistry.get_workflow_by_name(file_name)
             # We'll use its creation date.
             creation_date = prior_workflow.metadata.creation_date
+        elif file_name:
+            # If no prior workflow exists for the new name, check if there's a current workflow
+            # context (e.g., during rename operations) to preserve metadata from
+            context_manager = GriptapeNodes.ContextManager()
+            if context_manager.has_current_workflow():
+                current_workflow_name = context_manager.get_current_workflow_name()
+                if current_workflow_name and WorkflowRegistry.has_workflow_with_name(current_workflow_name):
+                    prior_workflow = WorkflowRegistry.get_workflow_by_name(current_workflow_name)
+                    creation_date = prior_workflow.metadata.creation_date
 
         if (creation_date is None) or (creation_date == WorkflowManager.EPOCH_START):
             # Either a new workflow, or a backcompat situation.
-            creation_date = datetime.now(tz=local_tz)
+            creation_date = datetime.now(tz=UTC)
 
         # Let's see if this is a template file; if so, re-route it as a copy in the customer's workflow directory.
         if prior_workflow and prior_workflow.metadata.is_template:
@@ -1181,14 +1336,17 @@ class WorkflowManager:
 
         # Get file name stuff prepped.
         if not file_name:
-            file_name = datetime.now(tz=local_tz).strftime("%d.%m_%H.%M")
+            file_name = datetime.now(tz=UTC).strftime("%d.%m_%H.%M")
         relative_file_path = f"{file_name}.py"
         file_path = GriptapeNodes.ConfigManager().workspace_path.joinpath(relative_file_path)
 
         # Generate the workflow file contents
         try:
             final_code_output, workflow_metadata = self._generate_workflow_file_contents_and_metadata(
-                file_name=file_name, creation_date=creation_date, image_path=request.image_path
+                file_name=file_name,
+                creation_date=creation_date,
+                image_path=request.image_path,
+                prior_workflow=prior_workflow,
             )
         except Exception as err:
             details = f"Attempted to save workflow '{relative_file_path}', but {err}"
@@ -1231,19 +1389,27 @@ class WorkflowManager:
                 logger.error("Attempted to save workflow '%s'. Failed when saving configuration: %s", file_name, str(e))
                 return SaveWorkflowResultFailure()
             WorkflowRegistry.generate_new_workflow(metadata=workflow_metadata, file_path=relative_file_path)
+        # Update existing workflow's metadata in the registry
+        existing_workflow = WorkflowRegistry.get_workflow_by_name(file_name)
+        existing_workflow.metadata = workflow_metadata
         details = f"Successfully saved workflow to: {serialized_file_path}"
         logger.info(details)
         return SaveWorkflowResultSuccess(file_path=str(serialized_file_path))
 
-    def _generate_workflow_metadata(
+    def _generate_workflow_metadata(  # noqa: PLR0913
         self,
         file_name: str,
         engine_version: str,
         creation_date: datetime,
         node_libraries_referenced: list[LibraryNameAndVersion],
         workflows_referenced: list[str] | None = None,
+        prior_workflow: Workflow | None = None,
     ) -> WorkflowMetadata | None:
-        local_tz = datetime.now().astimezone().tzinfo
+        # Preserve branched workflow information if it exists
+        branched_from = None
+        if prior_workflow and prior_workflow.metadata.branched_from:
+            branched_from = prior_workflow.metadata.branched_from
+
         workflow_metadata = WorkflowMetadata(
             name=str(file_name),
             schema_version=WorkflowMetadata.LATEST_SCHEMA_VERSION,
@@ -1251,11 +1417,35 @@ class WorkflowManager:
             node_libraries_referenced=node_libraries_referenced,
             workflows_referenced=workflows_referenced,
             creation_date=creation_date,
-            last_modified_date=datetime.now(tz=local_tz),
+            last_modified_date=datetime.now(tz=UTC),
+            branched_from=branched_from,
         )
 
         return workflow_metadata
 
+    def _replace_workflow_metadata_header(self, workflow_content: str, new_metadata: WorkflowMetadata) -> str | None:
+        """Replace the metadata header in a workflow file with new metadata.
+
+        Args:
+            workflow_content: The full content of the workflow file
+            new_metadata: The new metadata to replace the existing header with
+
+        Returns:
+            The workflow content with updated metadata header, or None if replacement failed
+        """
+        import re
+
+        # Generate the new metadata header
+        new_metadata_header = self._generate_workflow_metadata_header(new_metadata)
+        if new_metadata_header is None:
+            return None
+
+        # Replace the metadata block using regex
+        metadata_pattern = r"(# /// script\n)(.*?)(# ///)"
+        updated_content = re.sub(metadata_pattern, new_metadata_header, workflow_content, flags=re.DOTALL)
+
+        return updated_content
+
     def _generate_workflow_metadata_header(self, workflow_metadata: WorkflowMetadata) -> str | None:
         try:
             toml_doc = tomlkit.document()
@@ -2776,13 +2966,47 @@ class WorkflowManager:
                 msg = f"No publishing handler found for '{publisher_name}' in request type '{type(request).__name__}'."
                 raise ValueError(msg)  # noqa: TRY301
 
-            return publishing_handler.handler(request)
-
+            result = publishing_handler.handler(request)
+            if isinstance(result, PublishWorkflowResultSuccess):
+                file = Path(result.published_workflow_file_path)
+                self._register_published_workflow_file(file)
+            return result  # noqa: TRY300
         except Exception as e:
             details = f"Failed to publish workflow '{request.workflow_name}': {e!s}"
             logger.exception(details)
             return PublishWorkflowResultFailure(exception=e)
 
+    def _register_published_workflow_file(self, workflow_file: Path) -> None:
+        """Register a published workflow file in the workflow registry."""
+        if workflow_file.exists() and workflow_file.is_file():
+            load_workflow_metadata_request = LoadWorkflowMetadata(
+                file_name=workflow_file.name,
+            )
+            load_metadata_result = self.on_load_workflow_metadata_request(load_workflow_metadata_request)
+            if isinstance(load_metadata_result, LoadWorkflowMetadataResultSuccess):
+                register_workflow_result = self.on_register_workflow_request(
+                    RegisterWorkflowRequest(
+                        metadata=load_metadata_result.metadata,
+                        file_name=workflow_file.name,
+                    )
+                )
+                if isinstance(register_workflow_result, RegisterWorkflowResultSuccess):
+                    logger.info(
+                        "Successfully registered new workflow with file '%s'.",
+                        workflow_file.name,
+                    )
+                else:
+                    logger.warning(
+                        "Failed to register workflow with file '%s': %s",
+                        workflow_file.name,
+                        cast("RegisterWorkflowResultFailure", register_workflow_result).exception,
+                    )
+            else:
+                logger.warning(
+                    "Failed to load metadata for workflow file '%s'. Not registering workflow.",
+                    workflow_file.name,
+                )
+
     def on_import_workflow_as_referenced_sub_flow_request(
         self, request: ImportWorkflowAsReferencedSubFlowRequest
     ) -> ResultPayload:
@@ -2924,6 +3148,341 @@ class WorkflowManager:
         )
         return ImportWorkflowAsReferencedSubFlowResultSuccess(created_flow_name=created_flow_name)
 
+    def on_branch_workflow_request(self, request: BranchWorkflowRequest) -> ResultPayload:
+        """Create a branch (copy) of an existing workflow with branch tracking."""
+        try:
+            # Validate source workflow exists
+            source_workflow = WorkflowRegistry.get_workflow_by_name(request.workflow_name)
+        except KeyError:
+            logger.error("Failed to branch workflow '%s' because it does not exist", request.workflow_name)
+            return BranchWorkflowResultFailure()
+
+        # Generate branch name if not provided
+        branch_name = request.branched_workflow_name
+        if branch_name is None:
+            base_name = request.workflow_name
+            counter = 1
+            branch_name = f"{base_name}_branch_{counter}"
+            while WorkflowRegistry.has_workflow_with_name(branch_name):
+                counter += 1
+                branch_name = f"{base_name}_branch_{counter}"
+
+        # Check if branch name already exists
+        if WorkflowRegistry.has_workflow_with_name(branch_name):
+            logger.error(
+                "Failed to branch workflow '%s' because branch name '%s' already exists",
+                request.workflow_name,
+                branch_name,
+            )
+            return BranchWorkflowResultFailure()
+
+        try:
+            # Create branch metadata by copying source metadata
+            branch_metadata = WorkflowMetadata(
+                name=branch_name,
+                schema_version=source_workflow.metadata.schema_version,
+                engine_version_created_with=source_workflow.metadata.engine_version_created_with,
+                node_libraries_referenced=source_workflow.metadata.node_libraries_referenced.copy(),
+                workflows_referenced=source_workflow.metadata.workflows_referenced.copy()
+                if source_workflow.metadata.workflows_referenced
+                else None,
+                description=source_workflow.metadata.description,
+                image=source_workflow.metadata.image,
+                is_griptape_provided=False,  # Branches are always user-created
+                is_template=False,
+                creation_date=datetime.now(tz=UTC),
+                last_modified_date=source_workflow.metadata.last_modified_date,
+                branched_from=request.workflow_name,
+            )
+
+            # Prepare branch file path
+            branch_file_path = f"{branch_name}.py"
+
+            # Read source workflow content and replace metadata header
+            source_file_path = WorkflowRegistry.get_complete_file_path(source_workflow.file_path)
+            if not Path(source_file_path).exists():
+                logger.error(
+                    "Failed to branch workflow '%s': File path '%s' does not exist. "
+                    "The workflow may have been moved or the workspace configuration may have changed.",
+                    request.workflow_name,
+                    source_file_path,
+                )
+                return BranchWorkflowResultFailure()
+
+            source_content = Path(source_file_path).read_text(encoding="utf-8")
+
+            # Replace the metadata header with branch metadata
+            branch_content = self._replace_workflow_metadata_header(source_content, branch_metadata)
+            if branch_content is None:
+                logger.error("Failed to replace metadata header for branch workflow '%s'", branch_name)
+                return BranchWorkflowResultFailure()
+
+            # Write branch workflow file to disk BEFORE registering in registry
+            branch_full_path = WorkflowRegistry.get_complete_file_path(branch_file_path)
+            Path(branch_full_path).write_text(branch_content, encoding="utf-8")
+
+            # Now create the branch workflow in registry (file must exist on disk first)
+            WorkflowRegistry.generate_new_workflow(metadata=branch_metadata, file_path=branch_file_path)
+
+            # Register the branch in user configuration
+            config_manager = GriptapeNodes.ConfigManager()
+            config_manager.save_user_workflow_json(branch_full_path)
+
+            logger.info("Successfully branched workflow '%s' as '%s'", request.workflow_name, branch_name)
+            return BranchWorkflowResultSuccess(
+                branched_workflow_name=branch_name, original_workflow_name=request.workflow_name
+            )
+
+        except Exception as e:
+            logger.error("Failed to branch workflow '%s': %s", request.workflow_name, str(e))
+            import traceback
+
+            traceback.print_exc()
+            return BranchWorkflowResultFailure()
+
+    def on_merge_workflow_branch_request(self, request: MergeWorkflowBranchRequest) -> ResultPayload:
+        """Merge a branch back into its source workflow, removing the branch when complete."""
+        try:
+            # Validate branch workflow exists
+            branch_workflow = WorkflowRegistry.get_workflow_by_name(request.workflow_name)
+        except KeyError as e:
+            logger.error("Failed to merge workflow branch because it does not exist: %s", str(e))
+            return MergeWorkflowBranchResultFailure()
+
+        # Get source workflow name from branch metadata
+        source_workflow_name = branch_workflow.metadata.branched_from
+        if not source_workflow_name:
+            logger.error(
+                "Failed to merge workflow branch '%s' because it has no source workflow",
+                request.workflow_name,
+            )
+            return MergeWorkflowBranchResultFailure()
+
+        # Validate source workflow exists
+        try:
+            source_workflow = WorkflowRegistry.get_workflow_by_name(source_workflow_name)
+        except KeyError:
+            logger.error(
+                "Failed to merge workflow branch '%s' because source workflow '%s' does not exist",
+                request.workflow_name,
+                source_workflow_name,
+            )
+            return MergeWorkflowBranchResultFailure()
+
+        try:
+            # Create updated metadata for source workflow - update timestamp
+            merged_metadata = WorkflowMetadata(
+                name=source_workflow_name,
+                schema_version=source_workflow.metadata.schema_version,
+                engine_version_created_with=source_workflow.metadata.engine_version_created_with,
+                node_libraries_referenced=source_workflow.metadata.node_libraries_referenced.copy(),
+                workflows_referenced=source_workflow.metadata.workflows_referenced.copy()
+                if source_workflow.metadata.workflows_referenced
+                else None,
+                description=source_workflow.metadata.description,
+                image=source_workflow.metadata.image,
+                is_griptape_provided=source_workflow.metadata.is_griptape_provided,
+                is_template=source_workflow.metadata.is_template,
+                creation_date=source_workflow.metadata.creation_date,
+                last_modified_date=datetime.now(tz=UTC),
+                branched_from=source_workflow.metadata.branched_from,  # Preserve original source chain
+            )
+
+            # Read branch content and replace metadata header with merged metadata
+            branch_content_file_path = WorkflowRegistry.get_complete_file_path(branch_workflow.file_path)
+            branch_content = Path(branch_content_file_path).read_text(encoding="utf-8")
+
+            # Replace the metadata header with merged metadata
+            merged_content = self._replace_workflow_metadata_header(branch_content, merged_metadata)
+            if merged_content is None:
+                logger.error("Failed to replace metadata header for merged workflow '%s'", source_workflow_name)
+                return MergeWorkflowBranchResultFailure()
+
+            # Write the updated content to the source workflow file
+            source_file_path = WorkflowRegistry.get_complete_file_path(source_workflow.file_path)
+            Path(source_file_path).write_text(merged_content, encoding="utf-8")
+
+            # Update the registry with new metadata for the source workflow
+            source_workflow.metadata = merged_metadata
+
+            # Remove the branch workflow from registry and delete file
+            try:
+                WorkflowRegistry.delete_workflow_by_name(request.workflow_name)
+                Path(branch_content_file_path).unlink()
+                logger.info("Deleted branch workflow file and registry entry for '%s'", request.workflow_name)
+            except Exception as delete_error:
+                logger.warning(
+                    "Failed to fully clean up branch workflow '%s': %s",
+                    request.workflow_name,
+                    str(delete_error),
+                )
+                # Continue anyway - the merge was successful even if cleanup failed
+
+            logger.info(
+                "Successfully merged branch workflow '%s' into source workflow '%s'",
+                request.workflow_name,
+                source_workflow_name,
+            )
+            return MergeWorkflowBranchResultSuccess(merged_workflow_name=source_workflow_name)
+
+        except Exception as e:
+            logger.error(
+                "Failed to merge branch workflow '%s' into source workflow '%s': %s",
+                request.workflow_name,
+                source_workflow_name,
+                str(e),
+            )
+            return MergeWorkflowBranchResultFailure()
+
+    def on_reset_workflow_branch_request(self, request: ResetWorkflowBranchRequest) -> ResultPayload:
+        """Reset a branch to match its source workflow, discarding branch changes."""
+        try:
+            # Validate branch workflow exists
+            branch_workflow = WorkflowRegistry.get_workflow_by_name(request.workflow_name)
+        except KeyError as e:
+            logger.error("Failed to reset workflow branch because it does not exist: %s", str(e))
+            return ResetWorkflowBranchResultFailure()
+
+        # Get source workflow name from branch metadata
+        source_workflow_name = branch_workflow.metadata.branched_from
+        if not source_workflow_name:
+            logger.error(
+                "Failed to reset workflow branch '%s' because it has no source workflow",
+                request.workflow_name,
+            )
+            return ResetWorkflowBranchResultFailure()
+
+        # Validate source workflow exists
+        try:
+            source_workflow = WorkflowRegistry.get_workflow_by_name(source_workflow_name)
+        except KeyError:
+            logger.error(
+                "Failed to reset workflow branch '%s' because source workflow '%s' does not exist",
+                request.workflow_name,
+                source_workflow_name,
+            )
+            return ResetWorkflowBranchResultFailure()
+
+        try:
+            # Read content from the source workflow (what we're resetting the branch to)
+            source_content_file_path = WorkflowRegistry.get_complete_file_path(source_workflow.file_path)
+            source_content = Path(source_content_file_path).read_text(encoding="utf-8")
+
+            # Create updated metadata for branch workflow - preserve branch relationship and source timestamp
+            reset_metadata = WorkflowMetadata(
+                name=request.workflow_name,
+                schema_version=source_workflow.metadata.schema_version,
+                engine_version_created_with=source_workflow.metadata.engine_version_created_with,
+                node_libraries_referenced=source_workflow.metadata.node_libraries_referenced.copy(),
+                workflows_referenced=source_workflow.metadata.workflows_referenced.copy()
+                if source_workflow.metadata.workflows_referenced
+                else None,
+                description=source_workflow.metadata.description,
+                image=source_workflow.metadata.image,
+                is_griptape_provided=branch_workflow.metadata.is_griptape_provided,
+                is_template=branch_workflow.metadata.is_template,
+                creation_date=branch_workflow.metadata.creation_date,
+                last_modified_date=source_workflow.metadata.last_modified_date,
+                branched_from=source_workflow_name,  # Preserve branch relationship
+            )
+
+            # Replace the metadata header with reset metadata
+            reset_content = self._replace_workflow_metadata_header(source_content, reset_metadata)
+            if reset_content is None:
+                logger.error("Failed to replace metadata header for reset branch workflow '%s'", request.workflow_name)
+                return ResetWorkflowBranchResultFailure()
+
+            # Write the updated content to the branch workflow file
+            branch_content_file_path = WorkflowRegistry.get_complete_file_path(branch_workflow.file_path)
+            Path(branch_content_file_path).write_text(reset_content, encoding="utf-8")
+
+            # Update the registry with new metadata for the branch workflow
+            branch_workflow.metadata = reset_metadata
+
+        except Exception as e:
+            logger.error(
+                "Failed to reset branch workflow '%s' to source workflow '%s': %s",
+                request.workflow_name,
+                source_workflow_name,
+                str(e),
+            )
+            return ResetWorkflowBranchResultFailure()
+        else:
+            logger.info(
+                "Successfully reset branch workflow '%s' to match source workflow '%s'",
+                request.workflow_name,
+                source_workflow_name,
+            )
+            return ResetWorkflowBranchResultSuccess(reset_workflow_name=request.workflow_name)
+
+    def on_compare_workflows_request(self, request: CompareWorkflowsRequest) -> ResultPayload:
+        """Compare two workflows to determine if one is ahead, behind, or up-to-date relative to the other."""
+        try:
+            # Get the workflow to evaluate
+            workflow = WorkflowRegistry.get_workflow_by_name(request.workflow_name)
+        except KeyError:
+            logger.error("Failed to compare workflow '%s' because it does not exist", request.workflow_name)
+            return CompareWorkflowsResultFailure()
+
+        # Use the provided compare_workflow_name
+        compare_workflow_name = request.compare_workflow_name
+
+        # Try to get the source workflow
+        try:
+            source_workflow = WorkflowRegistry.get_workflow_by_name(compare_workflow_name)
+        except KeyError:
+            # Source workflow no longer exists
+            details = f"Source workflow '{compare_workflow_name}' for '{request.workflow_name}' no longer exists"
+            return CompareWorkflowsResultSuccess(
+                workflow_name=request.workflow_name,
+                compare_workflow_name=compare_workflow_name,
+                status="no_source",
+                workflow_last_modified=workflow.metadata.last_modified_date.isoformat()
+                if workflow.metadata.last_modified_date
+                else None,
+                source_last_modified=None,
+                details=details,
+            )
+
+        # Compare last modified dates
+        workflow_last_modified = workflow.metadata.last_modified_date
+        source_last_modified = source_workflow.metadata.last_modified_date
+
+        # Handle missing timestamps
+        if workflow_last_modified is None or source_last_modified is None:
+            details = f"Cannot compare timestamps - workflow: {workflow_last_modified}, source: {source_last_modified}"
+            logger.warning(details)
+            return CompareWorkflowsResultSuccess(
+                workflow_name=request.workflow_name,
+                compare_workflow_name=compare_workflow_name,
+                status="diverged",
+                workflow_last_modified=workflow_last_modified.isoformat() if workflow_last_modified else None,
+                source_last_modified=source_last_modified.isoformat() if source_last_modified else None,
+                details=details,
+            )
+
+        # Compare timestamps to determine status
+        if workflow_last_modified == source_last_modified:
+            status = "up_to_date"
+            details = f"Workflow '{request.workflow_name}' is up-to-date with source '{compare_workflow_name}'"
+        elif workflow_last_modified > source_last_modified:
+            status = "ahead"
+            details = f"Workflow '{request.workflow_name}' is ahead of source '{compare_workflow_name}' (local changes)"
+        else:
+            status = "behind"
+            details = (
+                f"Workflow '{request.workflow_name}' is behind source '{compare_workflow_name}' (source has updates)"
+            )
+
+        return CompareWorkflowsResultSuccess(
+            workflow_name=request.workflow_name,
+            compare_workflow_name=compare_workflow_name,
+            status=status,
+            workflow_last_modified=workflow_last_modified.isoformat(),
+            source_last_modified=source_last_modified.isoformat(),
+            details=details,
+        )
+
     def _walk_object_tree(
         self, obj: Any, process_class_fn: Callable[[type, Any], None], visited: set[int] | None = None
     ) -> None:
@@ -3076,6 +3635,101 @@ class WorkflowManager:
 
         self._walk_object_tree(obj, collect_class_import)
 
+    def on_register_workflows_from_config_request(self, request: RegisterWorkflowsFromConfigRequest) -> ResultPayload:
+        """Register workflows from a configuration section."""
+        try:
+            workflows_to_register = GriptapeNodes.ConfigManager().get_config_value(request.config_section)
+            if not workflows_to_register:
+                logger.info("No workflows found in configuration section '%s'", request.config_section)
+                return RegisterWorkflowsFromConfigResultSuccess(succeeded_workflows=[], failed_workflows=[])
+
+            # Process all workflows and track results
+            succeeded, failed = self._process_workflows_for_registration(workflows_to_register)
+
+        except Exception as e:
+            logger.error(
+                "Failed to register workflows from configuration section '%s': %s", request.config_section, str(e)
+            )
+            return RegisterWorkflowsFromConfigResultFailure()
+        else:
+            return RegisterWorkflowsFromConfigResultSuccess(succeeded_workflows=succeeded, failed_workflows=failed)
+
+    def _process_workflows_for_registration(self, workflows_to_register: list[str]) -> WorkflowRegistrationResult:
+        """Process a list of workflow paths for registration.
+
+        Returns:
+            WorkflowRegistrationResult with succeeded and failed workflow names
+        """
+        succeeded = []
+        failed = []
+
+        for workflow_to_register in workflows_to_register:
+            path = Path(workflow_to_register)
+
+            if path.is_dir():
+                dir_result = self._process_workflow_directory(path)
+                succeeded.extend(dir_result.succeeded)
+                failed.extend(dir_result.failed)
+            elif path.suffix == ".py":
+                workflow_name = self._process_single_workflow_file(path)
+                if workflow_name:
+                    succeeded.append(workflow_name)
+                else:
+                    failed.append(str(path))
+
+        return WorkflowRegistrationResult(succeeded=succeeded, failed=failed)
+
+    def _process_workflow_directory(self, directory_path: Path) -> WorkflowRegistrationResult:
+        """Process all workflow files in a directory.
+
+        Returns:
+            WorkflowRegistrationResult with succeeded and failed workflow names
+        """
+        succeeded = []
+        failed = []
+
+        for workflow_file in directory_path.glob("*.py"):
+            # Check that the python file has script metadata
+            metadata_blocks = self.get_workflow_metadata(
+                workflow_file, block_name=WorkflowManager.WORKFLOW_METADATA_HEADER
+            )
+            if len(metadata_blocks) == 1:
+                workflow_name = self._process_single_workflow_file(workflow_file)
+                if workflow_name:
+                    succeeded.append(workflow_name)
+                else:
+                    failed.append(str(workflow_file))
+
+        return WorkflowRegistrationResult(succeeded=succeeded, failed=failed)
+
+    def _process_single_workflow_file(self, workflow_file: Path) -> str | None:
+        """Process a single workflow file for registration.
+
+        Returns:
+            Workflow name if registered successfully, None if failed or skipped
+        """
+        # Parse metadata once and use it for both registration check and actual registration
+        load_metadata_request = LoadWorkflowMetadata(file_name=str(workflow_file))
+        load_metadata_result = self.on_load_workflow_metadata_request(load_metadata_request)
+
+        if not isinstance(load_metadata_result, LoadWorkflowMetadataResultSuccess):
+            logger.debug("Skipping workflow with invalid metadata: %s", workflow_file)
+            return None
+
+        workflow_metadata = load_metadata_result.metadata
+
+        # Check if workflow is already registered using the parsed metadata
+        if WorkflowRegistry.has_workflow_with_name(workflow_metadata.name):
+            logger.debug("Skipping already registered workflow: %s", workflow_file)
+            return None
+
+        # Register workflow using existing method with parsed metadata available
+        # The _register_workflow method will re-parse metadata, but this is acceptable
+        # since we've already validated it's parseable and the duplicate work is minimal
+        if self._register_workflow(str(workflow_file)):
+            return workflow_metadata.name
+        return None
+
 
 class ASTContainer:
     """ASTContainer is a helper class to keep track of AST nodes and generate final code from them."""