griptape-nodes 0.62.3__py3-none-any.whl → 0.63.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/os_manager.py

@@ -3,12 +3,14 @@ import logging
 import mimetypes
 import os
 import shutil
+import stat
 import subprocess
 import sys
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, NamedTuple
 
+import aioshutil
 from binaryornot.check import is_binary
 from rich.console import Console
 
@@ -24,9 +26,15 @@ from griptape_nodes.retained_mode.events.os_events import (
     CreateFileRequest,
     CreateFileResultFailure,
     CreateFileResultSuccess,
+    DeleteFileRequest,
+    DeleteFileResultFailure,
+    DeleteFileResultSuccess,
     ExistingFilePolicy,
     FileIOFailureReason,
     FileSystemEntry,
+    GetFileInfoRequest,
+    GetFileInfoResultFailure,
+    GetFileInfoResultSuccess,
     ListDirectoryRequest,
     ListDirectoryResultFailure,
     ListDirectoryResultSuccess,
@@ -137,6 +145,14 @@ class OSManager:
                 request_type=CopyFileRequest, callback=self.on_copy_file_request
             )
 
+            event_manager.assign_manager_to_request_type(
+                request_type=DeleteFileRequest, callback=self.on_delete_file_request
+            )
+
+            event_manager.assign_manager_to_request_type(
+                request_type=GetFileInfoRequest, callback=self.on_get_file_info_request
+            )
+
             # Register for app initialization event to setup system resources
             event_manager.add_listener_to_app_event(AppInitializationComplete, self.on_app_initialization_complete)
 
@@ -518,10 +534,16 @@ class OSManager:
                     if not request.show_hidden and entry.name.startswith("."):
                         continue
 
+                    # Apply pattern filter if specified
+                    if request.pattern is not None and not entry.match(request.pattern):
+                        continue
+
                     try:
                         stat = entry.stat()
                         # Get path relative to workspace if within workspace
-                        _is_entry_in_workspace, entry_path = self._validate_workspace_path(entry)
+                        _, entry_path = self._validate_workspace_path(entry)
+                        # Also get absolute resolved path
+                        absolute_resolved_path = str(entry.resolve())
                         mime_type = self._detect_mime_type(entry)
                         entries.append(
                             FileSystemEntry(
@@ -531,6 +553,7 @@ class OSManager:
                                 size=stat.st_size,
                                 modified_time=stat.st_mtime,
                                 mime_type=mime_type,
+                                absolute_path=absolute_resolved_path,
                             )
                         )
                     except (OSError, PermissionError) as e:
@@ -1320,6 +1343,154 @@ class OSManager:
             result_details=f"File copied successfully: {source_path} -> {destination_path}",
         )
 
+    @staticmethod
+    def remove_readonly(func, path, excinfo) -> None:  # noqa: ANN001, ARG004
+        """Handles read-only files and long paths on Windows during shutil.rmtree.
+
+        https://stackoverflow.com/a/50924863
+        """
+        if not GriptapeNodes.OSManager().is_windows():
+            return
+
+        long_path = Path(GriptapeNodes.OSManager().normalize_path_for_platform(Path(path)))
+
+        try:
+            Path.chmod(long_path, stat.S_IWRITE)
+            func(long_path)
+        except Exception as e:
+            console.print(f"[red]Error removing read-only file: {path}[/red]")
+            console.print(f"[red]Details: {e}[/red]")
+            raise
+
+    async def on_delete_file_request(self, request: DeleteFileRequest) -> ResultPayload:  # noqa: PLR0911, PLR0912, C901
+        """Handle a request to delete a file or directory."""
+        # FAILURE CASES FIRST (per CLAUDE.md)
+
+        # Validate exactly one of path or file_entry provided and determine path to delete
+        if request.path is not None and request.file_entry is not None:
+            msg = "Attempted to delete file with both path and file_entry. Failed due to invalid parameters"
+            return DeleteFileResultFailure(failure_reason=FileIOFailureReason.INVALID_PATH, result_details=msg)
+
+        if request.path is not None:
+            path_to_delete = request.path
+        elif request.file_entry is not None:
+            path_to_delete = request.file_entry.path
+        else:
+            msg = "Attempted to delete file with neither path nor file_entry. Failed due to invalid parameters"
+            return DeleteFileResultFailure(failure_reason=FileIOFailureReason.INVALID_PATH, result_details=msg)
+
+        # Resolve and validate path
+        try:
+            resolved_path = self._resolve_file_path(path_to_delete, workspace_only=request.workspace_only is True)
+        except (ValueError, RuntimeError) as e:
+            msg = f"Attempted to delete file at path {path_to_delete}. Failed due to invalid path: {e}"
+            return DeleteFileResultFailure(failure_reason=FileIOFailureReason.INVALID_PATH, result_details=msg)
+
+        # Check if path exists
+        if not resolved_path.exists():
+            msg = f"Attempted to delete file at path {path_to_delete}. Failed due to path not found"
+            return DeleteFileResultFailure(failure_reason=FileIOFailureReason.FILE_NOT_FOUND, result_details=msg)
+
+        # Determine if this is a directory
+        is_directory = resolved_path.is_dir()
+
+        # Collect all paths that will be deleted (for reporting)
+        if is_directory:
+            # Collect all file and directory paths before deletion
+            deleted_paths = [str(item) for item in resolved_path.rglob("*")]
+            deleted_paths.append(str(resolved_path))
+        else:
+            deleted_paths = [str(resolved_path)]
+
+        # Perform deletion
+        try:
+            if is_directory:
+                await aioshutil.rmtree(resolved_path, onexc=OSManager.remove_readonly)
+            else:
+                resolved_path.unlink()
+        except PermissionError as e:
+            msg = f"Attempted to delete {'directory' if is_directory else 'file'} at path {path_to_delete}. Failed due to permission denied: {e}"
+            return DeleteFileResultFailure(failure_reason=FileIOFailureReason.PERMISSION_DENIED, result_details=msg)
+        except OSError as e:
+            msg = f"Attempted to delete {'directory' if is_directory else 'file'} at path {path_to_delete}. Failed due to I/O error: {e}"
+            return DeleteFileResultFailure(failure_reason=FileIOFailureReason.IO_ERROR, result_details=msg)
+        except Exception as e:
+            msg = f"Attempted to delete {'directory' if is_directory else 'file'} at path {path_to_delete}. Failed due to unexpected error: {type(e).__name__}: {e}"
+            return DeleteFileResultFailure(failure_reason=FileIOFailureReason.UNKNOWN, result_details=msg)
+
+        # SUCCESS PATH AT END
+        return DeleteFileResultSuccess(
+            deleted_path=str(resolved_path),
+            was_directory=is_directory,
+            deleted_paths=deleted_paths,
+            result_details=f"Successfully deleted {'directory' if is_directory else 'file'} at path {path_to_delete}",
+        )
+
+    def on_get_file_info_request(  # noqa: PLR0911
+        self, request: GetFileInfoRequest
+    ) -> GetFileInfoResultSuccess | GetFileInfoResultFailure:
+        """Handle a request to get file/directory information."""
+        # FAILURE CASES FIRST (per CLAUDE.md)
+
+        # Validate path provided
+        if not request.path:
+            msg = "Attempted to get file info with empty path. Failed due to invalid parameters"
+            return GetFileInfoResultFailure(failure_reason=FileIOFailureReason.INVALID_PATH, result_details=msg)
+
+        # Resolve and validate path
+        try:
+            resolved_path = self._resolve_file_path(request.path, workspace_only=request.workspace_only is True)
+        except (ValueError, RuntimeError) as e:
+            msg = f"Attempted to get file info at path {request.path}. Failed due to invalid path: {e}"
+            return GetFileInfoResultFailure(failure_reason=FileIOFailureReason.INVALID_PATH, result_details=msg)
+
+        # Check if path exists - if not, return success with None (file doesn't exist)
+        if not resolved_path.exists():
+            msg = f"File info retrieved for path {request.path}: file does not exist"
+            return GetFileInfoResultSuccess(file_entry=None, result_details=msg)
+
+        # Get file information
+        try:
+            is_dir = resolved_path.is_dir()
+            size = 0 if is_dir else resolved_path.stat().st_size
+            modified_time = resolved_path.stat().st_mtime
+
+            # Get MIME type for files only
+            mime_type = None
+            if not is_dir:
+                mime_type = self._detect_mime_type(resolved_path)
+
+            # Get path relative to workspace if within workspace
+            _, file_path = self._validate_workspace_path(resolved_path)
+
+            # Also get absolute resolved path
+            absolute_resolved_path = str(resolved_path.resolve())
+
+            file_entry = FileSystemEntry(
+                name=resolved_path.name,
+                path=str(file_path),
+                is_dir=is_dir,
+                size=size,
+                modified_time=modified_time,
+                mime_type=mime_type,
+                absolute_path=absolute_resolved_path,
+            )
+        except PermissionError as e:
+            msg = f"Attempted to get file info at path {request.path}. Failed due to permission denied: {e}"
+            return GetFileInfoResultFailure(failure_reason=FileIOFailureReason.PERMISSION_DENIED, result_details=msg)
+        except OSError as e:
+            msg = f"Attempted to get file info at path {request.path}. Failed due to I/O error: {e}"
+            return GetFileInfoResultFailure(failure_reason=FileIOFailureReason.IO_ERROR, result_details=msg)
+        except Exception as e:
+            msg = f"Attempted to get file info at path {request.path}. Failed due to unexpected error: {type(e).__name__}: {e}"
+            return GetFileInfoResultFailure(failure_reason=FileIOFailureReason.UNKNOWN, result_details=msg)
+
+        # SUCCESS PATH AT END
+        return GetFileInfoResultSuccess(
+            file_entry=file_entry,
+            result_details=f"Successfully retrieved file info for path {request.path}",
+        )
+
     def _validate_copy_tree_paths(
         self, source_str: str, dest_str: str, *, dirs_exist_ok: bool
     ) -> CopyTreeValidationResult | CopyTreeResultFailure:

griptape_nodes/retained_mode/managers/settings.py

@@ -217,6 +217,11 @@ class Settings(BaseModel):
         default="synced_workflows",
         description="Path to the synced workflows directory, relative to the workspace directory.",
     )
+    thread_storage_backend: Literal["local", "gtc"] = Field(
+        category=STORAGE,
+        default="local",
+        description="Storage backend for conversation threads: 'local' for filesystem or 'gtc' for Griptape Cloud",
+    )
     enable_workspace_file_watching: bool = Field(
         category=FILE_SYSTEM,
         default=True,

griptape_nodes/retained_mode/managers/version_compatibility_manager.py

@@ -17,14 +17,29 @@ from griptape_nodes.retained_mode.events.library_events import (
     GetLibraryMetadataResultSuccess,
     GetNodeMetadataFromLibraryRequest,
     GetNodeMetadataFromLibraryResultSuccess,
+    ListNodeTypesInLibraryRequest,
+    ListNodeTypesInLibraryResultSuccess,
+    ListRegisteredLibrariesRequest,
+    ListRegisteredLibrariesResultSuccess,
 )
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.deprecated_node_warning_problem import (
+    DeprecatedNodeWarningProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.deprecated_node_in_workflow_problem import (
+    DeprecatedNodeInWorkflowProblem,
+)
+from griptape_nodes.retained_mode.managers.fitness_problems.workflows.node_type_not_found_problem import (
+    NodeTypeNotFoundProblem,
+)
 from griptape_nodes.retained_mode.managers.library_lifecycle.library_status import LibraryStatus
 
 if TYPE_CHECKING:
     from griptape_nodes.node_library.library_registry import LibrarySchema
     from griptape_nodes.node_library.workflow_registry import WorkflowMetadata
     from griptape_nodes.retained_mode.managers.event_manager import EventManager
+    from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+    from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_problem import WorkflowProblem
     from griptape_nodes.retained_mode.managers.workflow_manager import WorkflowManager
 
 logger = logging.getLogger("griptape_nodes")
@@ -33,7 +48,7 @@ logger = logging.getLogger("griptape_nodes")
 class LibraryVersionCompatibilityIssue(NamedTuple):
     """Represents a library version compatibility issue found in a library."""
 
-    message: str
+    problem: LibraryProblem
     severity: LibraryStatus
 
 
@@ -52,7 +67,7 @@ class LibraryVersionCompatibilityCheck(ABC):
 class WorkflowVersionCompatibilityIssue(NamedTuple):
     """Represents a workflow version compatibility issue found in a workflow."""
 
-    message: str
+    problem: WorkflowProblem
     severity: WorkflowManager.WorkflowStatus
 
 
@@ -165,7 +180,12 @@ class VersionCompatibilityManager:
         """Check a library for deprecated nodes."""
         return [
             LibraryVersionCompatibilityIssue(
-                message=f"Node '{node.metadata.display_name}' (class: {node.class_name}) is deprecated and {'will be removed in version ' + node.metadata.deprecation.removal_version if node.metadata.deprecation.removal_version else 'may be removed in future versions'}. {node.metadata.deprecation.deprecation_message or ''}".strip(),
+                problem=DeprecatedNodeWarningProblem(
+                    display_name=node.metadata.display_name,
+                    class_name=node.class_name,
+                    removal_version=node.metadata.deprecation.removal_version,
+                    deprecation_message=node.metadata.deprecation.deprecation_message,
+                ),
                 severity=LibraryStatus.FLAWED,
             )
             for node in library_data.nodes
@@ -205,7 +225,7 @@ class VersionCompatibilityManager:
 
         return version_issues
 
-    def _check_workflow_for_deprecated_nodes(  # noqa: C901, PLR0912
+    def _check_workflow_for_deprecated_nodes(  # noqa: C901
         self, workflow_metadata: WorkflowMetadata
     ) -> list[WorkflowVersionCompatibilityIssue]:
         """Check a workflow for deprecated nodes.
@@ -215,18 +235,33 @@ class VersionCompatibilityManager:
         """
         issues: list[WorkflowVersionCompatibilityIssue] = []
 
+        # Get list of registered libraries once (silent check - no error logging)
+        list_request = ListRegisteredLibrariesRequest()
+        list_result = GriptapeNodes.LibraryManager().on_list_registered_libraries_request(list_request)
+
+        if not isinstance(list_result, ListRegisteredLibrariesResultSuccess):
+            # Should not happen, but handle gracefully - return empty issues
+            return issues
+
+        registered_libraries = list_result.libraries
+
         for library_name_and_node_type in workflow_metadata.node_types_used:
             library_name = library_name_and_node_type.library_name
             node_type = library_name_and_node_type.node_type
 
-            # Get library metadata to check if library exists and get version
+            # Check if library is registered
+            if library_name not in registered_libraries:
+                # Library not registered - skip this node silently, other checks handle missing libraries
+                continue
+
+            # Get library metadata to get version
             library_metadata_request = GetLibraryMetadataRequest(library=library_name)
             library_metadata_result = GriptapeNodes.LibraryManager().get_library_metadata_request(
                 library_metadata_request
             )
 
             if not isinstance(library_metadata_result, GetLibraryMetadataResultSuccess):
-                # Library not found - skip this node, other checks handle missing libraries
+                # Should not happen since we verified library exists, but handle gracefully
                 continue
 
             current_library_version = library_metadata_result.metadata.library_version
@@ -238,29 +273,41 @@ class VersionCompatibilityManager:
                     workflow_library_version = lib_ref.library_version
                     break
 
-            # Get node metadata from library
-            node_metadata_request = GetNodeMetadataFromLibraryRequest(library=library_name, node_type=node_type)
-            node_metadata_result = GriptapeNodes.LibraryManager().get_node_metadata_from_library_request(
-                node_metadata_request
+            # Check if node type exists in library (silent check - no error logging)
+            list_node_types_request = ListNodeTypesInLibraryRequest(library=library_name)
+            list_node_types_result = GriptapeNodes.LibraryManager().on_list_node_types_in_library_request(
+                list_node_types_request
             )
 
-            if not isinstance(node_metadata_result, GetNodeMetadataFromLibraryResultSuccess):
-                # Node type doesn't exist in current library version
-                message = f"This workflow uses node type '{node_type}' from library '{library_name}', but this node type is not found in the current library version {current_library_version}"
-
-                if workflow_library_version:
-                    message += f". The workflow was saved with library version {workflow_library_version}"
-
-                message += ". This node may have been removed or renamed. Contact the library author for more details."
+            if not isinstance(list_node_types_result, ListNodeTypesInLibraryResultSuccess):
+                # Should not happen since we verified library exists, but handle gracefully
+                continue
 
+            if node_type not in list_node_types_result.node_types:
+                # Node type doesn't exist in current library version
                 issues.append(
                     WorkflowVersionCompatibilityIssue(
-                        message=message,
+                        problem=NodeTypeNotFoundProblem(
+                            node_type=node_type,
+                            library_name=library_name,
+                            current_library_version=current_library_version,
+                            workflow_library_version=workflow_library_version,
+                        ),
                         severity=GriptapeNodes.WorkflowManager().WorkflowStatus.FLAWED,
                     )
                 )
                 continue
 
+            # Get node metadata from library (we know the node exists now)
+            node_metadata_request = GetNodeMetadataFromLibraryRequest(library=library_name, node_type=node_type)
+            node_metadata_result = GriptapeNodes.LibraryManager().get_node_metadata_from_library_request(
+                node_metadata_request
+            )
+
+            if not isinstance(node_metadata_result, GetNodeMetadataFromLibraryResultSuccess):
+                # Should not happen since we verified node exists, but handle gracefully
+                continue
+
             node_metadata = node_metadata_result.metadata
 
             if node_metadata.deprecation is None:
@@ -268,40 +315,18 @@ class VersionCompatibilityManager:
 
             deprecation = node_metadata.deprecation
 
-            removal_version_reached = False
-            if deprecation.removal_version:
-                try:
-                    current_version = semver.VersionInfo.parse(current_library_version)
-                    removal_version = semver.VersionInfo.parse(deprecation.removal_version)
-                    removal_version_reached = current_version >= removal_version
-                except Exception:
-                    # Errored out trying to parse the version strings; assume not reached.
-                    removal_version_reached = False
-
-            # Build the complete message
-            message = f"This workflow uses node '{node_metadata.display_name}' (class: {node_type}) from library '{library_name}', which is deprecated"
-
-            if deprecation.removal_version:
-                if removal_version_reached:
-                    message += f" and was removed in version {deprecation.removal_version}"
-                else:
-                    message += f" and will be removed in version {deprecation.removal_version}"
-            else:
-                message += " and may be removed in future versions"
-
-            message += f". You are currently using library version: {current_library_version}"
-
-            if workflow_library_version:
-                message += f", and the workflow was saved with library version: {workflow_library_version}"
-
-            if deprecation.deprecation_message:
-                message += f". The library author provided the following message for this deprecation: {deprecation.deprecation_message}"
-            else:
-                message += ". The library author did not provide a message explaining the deprecation. Contact the library author for details on how to remedy this."
-
+            # Create deprecated node problem
             issues.append(
                 WorkflowVersionCompatibilityIssue(
-                    message=message,
+                    problem=DeprecatedNodeInWorkflowProblem(
+                        node_display_name=node_metadata.display_name,
+                        node_type=node_type,
+                        library_name=library_name,
+                        current_library_version=current_library_version,
+                        workflow_library_version=workflow_library_version,
+                        removal_version=deprecation.removal_version,
+                        deprecation_message=deprecation.deprecation_message,
+                    ),
                     severity=GriptapeNodes.WorkflowManager().WorkflowStatus.FLAWED,
                 )
             )