issues-fs 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

issues_fs/issues/status/Server__Status__Service.py

@@ -0,0 +1,113 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Server__Status__Service - Main server status orchestrator
+# Aggregates all status components into a comprehensive response
+# ═══════════════════════════════════════════════════════════════════════════════
+
+import sys
+from datetime                                                                                               import datetime
+from osbot_utils.type_safe.Type_Safe                                                                        import Type_Safe
+from osbot_utils.type_safe.primitives.domains.common.safe_str.Safe_Str__Text                                import Safe_Str__Text
+from issues_fs.schemas.status.Schema__API__Info                            import Schema__API__Info
+from issues_fs.schemas.status.Schema__Server__Status                       import Schema__Server__Status
+from issues_fs.schemas.status.Schema__Server__Status                       import Schema__Server__Status__Response
+from issues_fs.issues.status.Git__Status__Service                  import Git__Status__Service
+from issues_fs.issues.status.Index__Status__Service                import Index__Status__Service
+from issues_fs.issues.status.Storage__Status__Service              import Storage__Status__Service
+from issues_fs.issues.status.Types__Status__Service                import Types__Status__Service
+from issues_fs.utils.Version                                               import version__issues_fs
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Configuration Constants
+# ═══════════════════════════════════════════════════════════════════════════════
+
+API_VERSION     = '0.2.4'
+API_NAME        = 'Graph Issue Tracking API'
+BUILD_DATE      = 'NA'                              # see if we can get this from the .git folder
+ENVIRONMENT     = 'development'
+
+
+class Server__Status__Service(Type_Safe):                                        # Main status service
+    storage_service : Storage__Status__Service  = None                           # Storage status
+    git_service     : Git__Status__Service      = None                           # Git status
+    types_service   : Types__Status__Service    = None                           # Types status
+    index_service   : Index__Status__Service    = None                           # Index status
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Main Status Method
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def get_full_status(self) -> Schema__Server__Status__Response:               # Get comprehensive status
+
+        timestamp      = self._get_timestamp()
+        api_info       = self._get_api_info()
+        storage_status = self._get_storage_status()
+        git_status     = self._get_git_status()
+        types_status   = self._get_types_status()
+        index_status   = self._get_index_status()
+
+        status = Schema__Server__Status(timestamp      = Safe_Str__Text(timestamp)       ,
+                                        api            = api_info                        ,
+                                        storage        = storage_status                  ,
+                                        types          = types_status                    ,
+                                        index          = index_status                    ,
+                                        git            = git_status                      )
+
+        return Schema__Server__Status__Response(success = True                           ,
+                                                status  = status                         )
+
+        # except Exception as e:
+        #     return Schema__Server__Status__Response(success = False                          ,
+        #                                             message = Safe_Str__Text(f'Error: {str(e)}'))
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Individual Status Getters
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def get_api_info(self) -> Schema__API__Info:                                 # Public API info getter
+        return self._get_api_info()
+
+    def get_storage_status(self):                                                # Public storage status
+        return self._get_storage_status()
+
+    def get_git_status(self):                                                    # Public git status
+        return self._get_git_status()
+
+    def get_types_status(self):                                                  # Public types status
+        return self._get_types_status()
+
+    def get_index_status(self):                                                  # Public index status
+        return self._get_index_status()
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Private Status Methods
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def _get_timestamp(self) -> str:                                             # Get current timestamp
+        return datetime.utcnow().isoformat() + 'Z'
+
+    def _get_api_info(self) -> Schema__API__Info:                                # Build API info
+        return Schema__API__Info(version        = version__issues_fs                ,
+                                 build_date     = Safe_Str__Text(BUILD_DATE)                 ,
+                                 environment    = Safe_Str__Text(ENVIRONMENT)                ,
+                                 python_version = Safe_Str__Text(sys.version.split()[0])     ,
+                                 api_name       = Safe_Str__Text(API_NAME)                   )
+
+    def _get_storage_status(self):                                               # Get storage status
+        if self.storage_service:
+            return self.storage_service.get_status()
+        return None
+
+    def _get_git_status(self):                                                   # Get git status
+        if self.git_service:
+            return self.git_service.get_status()
+        return None
+
+    def _get_types_status(self):                                                 # Get types status
+        if self.types_service:
+            return self.types_service.get_status()
+        return None
+
+    def _get_index_status(self):                                                 # Get index status
+        if self.index_service:
+            return self.index_service.get_status()
+        return None

issues_fs/issues/status/Storage__Status__Service.py

@@ -0,0 +1,75 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Storage__Status__Service - Storage backend introspection
+# Inspects Memory-FS configuration and provides detailed status
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from osbot_utils.type_safe.Type_Safe                                                                        import Type_Safe
+from osbot_utils.type_safe.primitives.domains.common.safe_str.Safe_Str__Text                                import Safe_Str__Text
+from memory_fs.storage_fs.Storage_FS                                                                        import Storage_FS
+from issues_fs.schemas.status.Schema__Storage__Status                      import Schema__Storage__Status
+
+
+class Storage__Status__Service(Type_Safe):                                       # Storage status service
+    storage_fs : Storage_FS = None                                                 # Storage_FS instance
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Main Status Method
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def get_status(self) -> Schema__Storage__Status:                             # Get storage status
+        if self.storage_fs is None:
+            return Schema__Storage__Status(backend_type  = Safe_Str__Text('not_configured'),
+                                           is_connected  = False                            )
+
+        backend_type  = type(self.storage_fs).__name__
+
+        return Schema__Storage__Status(backend_type   = backend_type            ,
+                                       root_path      = self._get_root_path   (),
+                                       is_connected   = self._check_connection(),
+                                       is_writable    = self._check_writable  (),
+                                       file_count     = self._count_files     ())
+
+    def _get_root_path(self) -> str:                                 # Get configured root path
+
+        path_attrs = ['root_path', 'db_path', 'zip_path', 'bucket', 'base_path']
+        for attr in path_attrs:
+            if hasattr(self.storage_fs, attr):
+                value = getattr(self.storage_fs, attr, None)
+                if value:
+                    return str(value)
+        return ''
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Connectivity Methods
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def _check_connection(self) -> bool:                             # Test read connectivity
+        self.storage_fs.file__exists('__connectivity_test__')
+        return True
+
+    def _check_writable(self) -> bool:                               # Test write connectivity
+        with self.storage_fs as _:
+            test_path = '__write_test_temp__'
+            test_data = b'test'
+
+            if _.file__save(test_path, test_data):
+                if _.file__delete(test_path):
+                    return True
+            return False
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Statistics Methods
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def _count_files(self) -> int:                                   # Count stored files
+        return len(self.storage_fs.files__paths())
+
+    def _count_folders(self) -> int:                                        # Count folders
+        for method_name in ['folders__all', 'folders', 'list_folders']:     # todo: find a better way to do this
+            if hasattr(self.storage_fs, method_name):
+                method = getattr(self.storage_fs, method_name)
+                if callable(method):
+                    result = method()
+                    if result:
+                        return len(result)
+        return 0

issues_fs/issues/status/Types__Status__Service.py

@@ -0,0 +1,75 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Types__Status__Service - Node and link type configuration status
+# Reports on configured node types and link types
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from typing                                                                                                 import List, Optional
+from osbot_utils.type_safe.Type_Safe                                                                        import Type_Safe
+from osbot_utils.type_safe.primitives.core.Safe_UInt                                                        import Safe_UInt
+from osbot_utils.type_safe.primitives.domains.common.safe_str.Safe_Str__Text                                import Safe_Str__Text
+from osbot_utils.type_safe.type_safe_core.decorators.type_safe import type_safe
+
+from issues_fs.schemas.status.Schema__Types__Status                        import Schema__Types__Status, Schema__Node__Type__Summary, Schema__Link__Type__Summary
+from issues_fs.issues.graph_services.Type__Service                 import Type__Service
+
+
+class Types__Status__Service(Type_Safe):                                         # Types status service
+    type_service : Type__Service = None                                          # Type__Service instance
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Main Status Method
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def get_status(self) -> Schema__Types__Status:                               # Get types status
+        if self.type_service is None:
+            return Schema__Types__Status(is_initialized = False                              )
+
+        node_types   = self._get_node_type_summaries()
+        link_types   = self._get_link_type_summaries()
+        is_init      = len(node_types) > 0 or len(link_types) > 0
+
+        return Schema__Types__Status(is_initialized   = is_init                              ,
+                                     node_type_count  = Safe_UInt(len(node_types))           ,
+                                     link_type_count  = Safe_UInt(len(link_types))           ,
+                                     node_types       = node_types                           ,
+                                     link_types       = link_types                           )
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Node Types
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def _get_node_type_summaries(self) -> List[Schema__Node__Type__Summary]:     # Get node type summaries
+        summaries = []
+
+        node_types = self.type_service.list_node_types()
+        if node_types:
+            for note_type in node_types:
+                status_count = len(note_type.statuses)
+                summary = Schema__Node__Type__Summary(name         = note_type.name        ,
+                                                      display_name = note_type.display_name,
+                                                      color        = note_type.color       ,
+                                                      status_count = status_count   )
+                summaries.append(summary)
+
+
+        return summaries
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Link Types
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def _get_link_type_summaries(self) -> List[Schema__Link__Type__Summary]:     # Get link type summaries
+        summaries = []
+
+
+        link_types = self.type_service.list_link_types()
+        if link_types:
+            for link_type in link_types:
+
+                summary = Schema__Link__Type__Summary(verb         = link_type.verb                           ,
+                                                      inverse_verb = link_type.inverse_verb                   ,
+                                                      is_symmetric = link_type.verb == link_type.inverse_verb ) # todo: review the use of this, and if we need this, why we are mapping is_symmetric in Schema__Link__Type__Summary and not in Schema__Link__Type
+                summaries.append(summary)
+        return summaries

issues_fs/issues/status/__init__.py

@@ -0,0 +1,3 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Issue tracking services package
+# ═══════════════════════════════════════════════════════════════════════════════

issues_fs/issues/storage/Path__Handler__Graph_Node.py

@@ -0,0 +1,185 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Path__Handler__Graph_Node - Path generation for graph-based issue tracking
+# Phase 1: Added dual file support (issue.json preferred, node.json fallback)
+#
+# Storage structure:
+#   data/{node_type}/{Label}/issue.json    <- NEW: Preferred file
+#   data/{node_type}/{Label}/node.json     <- LEGACY: Read-only fallback
+#   data/{node_type}/{Label}/attachments/{filename}
+#   data/{node_type}/_index.json
+#   config/node-types.json
+#   config/link-types.json
+#   _index.json
+#   issue.json                             <- NEW: Root issue (optional)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from osbot_utils.type_safe.Type_Safe                                                         import Type_Safe
+from osbot_utils.type_safe.type_safe_core.decorators.type_safe                               import type_safe
+from osbot_utils.type_safe.primitives.domains.files.safe_str.Safe_Str__File__Path            import Safe_Str__File__Path
+from osbot_utils.type_safe.primitives.domains.files.safe_str.Safe_Str__File__Name            import Safe_Str__File__Name
+from issues_fs.schemas.graph.Safe_Str__Graph_Types          import Safe_Str__Node_Type, Safe_Str__Node_Label
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# File Name Constants
+# ═══════════════════════════════════════════════════════════════════════════════
+
+FILE_NAME__ISSUE_JSON = 'issue.json'                                             # NEW: Preferred issue data file
+FILE_NAME__NODE_JSON  = 'node.json'                                              # LEGACY: Fallback for backward compat
+
+# todo: quite a number of raw primitives used below (which need to type safe primitives)
+
+class Path__Handler__Graph_Node(Type_Safe):                                      # Path handler for graph nodes
+    base_path : Safe_Str__File__Path = '.issues'                                 # Root directory for issues (empty or '.' for local disk)
+
+    def path_prefix(self) -> str:                                                # Get prefix for paths (empty or base_path/)
+        if self.base_path and str(self.base_path) != '.':
+            return f"{self.base_path}/"
+        return ""
+
+    def has_base_path(self) -> bool:                                             # Check if base_path is set (not empty or '.')
+        return bool(self.base_path) and str(self.base_path) != '.'
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Issue File Paths (Phase 1: Dual File Support)
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def path_for_issue_json(self                              ,                  # Path to issue.json (preferred)
+                            node_type : Safe_Str__Node_Type   ,
+                            label     : Safe_Str__Node_Label
+                       ) -> str:
+        if self.has_base_path():
+            return f"{self.base_path}/data/{node_type}/{label}/{FILE_NAME__ISSUE_JSON}"
+        return f"data/{node_type}/{label}/{FILE_NAME__ISSUE_JSON}"
+
+    @type_safe
+    def path_for_node_json(self                              ,                   # Path to node.json (legacy)
+                           node_type : Safe_Str__Node_Type   ,
+                           label     : Safe_Str__Node_Label
+                      ) -> str:
+        if self.has_base_path():
+            return f"{self.base_path}/data/{node_type}/{label}/{FILE_NAME__NODE_JSON}"
+        return f"data/{node_type}/{label}/{FILE_NAME__NODE_JSON}"
+
+    @type_safe
+    def path_for_node(self                              ,                        # DEPRECATED: Use path_for_issue_json
+                      node_type : Safe_Str__Node_Type   ,                        # Kept for backward compatibility
+                      label     : Safe_Str__Node_Label
+                 ) -> str:
+        return self.path_for_node_json(node_type, label)                         # Returns legacy path
+
+    @type_safe
+    def path_for_node_folder(self                              ,                 # Path to node folder
+                             node_type : Safe_Str__Node_Type   ,
+                             label     : Safe_Str__Node_Label
+                        ) -> str:
+        if self.has_base_path():
+            return f"{self.base_path}/data/{node_type}/{label}"
+        return f"data/{node_type}/{label}"
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Root Issue Path (Phase 1: Root issue support)
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def path_for_root_issue(self) -> str:                                        # Path to root issue.json
+        if self.has_base_path():
+            return f"{self.base_path}/{FILE_NAME__ISSUE_JSON}"
+        return FILE_NAME__ISSUE_JSON
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Child Issues Folder (Phase 1: Hierarchical structure)
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def path_for_issues_folder(self                              ,               # Path to issues/ subfolder
+                               node_type : Safe_Str__Node_Type   ,
+                               label     : Safe_Str__Node_Label
+                          ) -> str:
+        if self.has_base_path():
+            return f"{self.base_path}/data/{node_type}/{label}/issues"
+        return f"data/{node_type}/{label}/issues"
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Attachment Paths
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def path_for_attachment(self                              ,                  # Path to attachment file
+                            node_type : Safe_Str__Node_Type   ,
+                            label     : Safe_Str__Node_Label  ,
+                            filename  : Safe_Str__File__Name
+                       ) -> str:
+        if self.has_base_path():
+            return f"{self.base_path}/data/{node_type}/{label}/attachments/{filename}"
+        return f"data/{node_type}/{label}/attachments/{filename}"
+
+    @type_safe
+    def path_for_attachments_folder(self                              ,          # Path to attachments folder
+                                    node_type : Safe_Str__Node_Type   ,
+                                    label     : Safe_Str__Node_Label
+                               ) -> str:
+        if self.has_base_path():
+            return f"{self.base_path}/data/{node_type}/{label}/attachments"
+        return f"data/{node_type}/{label}/attachments"
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Index Paths
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def path_for_type_index(self                              ,                  # Path to per-type index
+                            node_type : Safe_Str__Node_Type
+                       ) -> str:
+        if self.has_base_path():
+            return f"{self.base_path}/data/{node_type}/_index.json"
+        return f"data/{node_type}/_index.json"
+
+    def path_for_global_index(self) -> str:                                      # Path to global index
+        if self.has_base_path():
+            return f"{self.base_path}/_index.json"
+        return "_index.json"
+
+    @type_safe
+    def path_for_type_folder(self                              ,                 # Path to type folder
+                             node_type : Safe_Str__Node_Type
+                        ) -> str:
+        if self.has_base_path():
+            return f"{self.base_path}/data/{node_type}"
+        return f"data/{node_type}"
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Config Paths
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def path_for_node_types(self) -> str:                                        # Path to node-types.json
+        if self.has_base_path():
+            return f"{self.base_path}/config/node-types.json"
+        return "config/node-types.json"
+
+    def path_for_link_types(self) -> str:                                        # Path to link-types.json
+        if self.has_base_path():
+            return f"{self.base_path}/config/link-types.json"
+        return "config/link-types.json"
+
+    def path_for_settings(self) -> str:                                          # Path to settings.json
+        if self.has_base_path():
+            return f"{self.base_path}/config/settings.json"
+        return "config/settings.json"
+
+    def path_for_config_folder(self) -> str:                                     # Path to config folder
+        if self.has_base_path():
+            return f"{self.base_path}/config"
+        return "config"
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Label Generation
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def label_from_type_and_index(self                              ,            # Generate label from type + index
+                                  node_type  : Safe_Str__Node_Type  ,            # e.g., "bug"
+                                  node_index : int                               # e.g., 27
+                             ) -> Safe_Str__Node_Label:
+        display_type = node_type.capitalize()                                    # "bug" → "Bug"
+        return Safe_Str__Node_Label(f"{display_type}-{node_index}")              # "Bug-27"

issues_fs/issues/storage/Path__Handler__Issues.py

@@ -0,0 +1,57 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Path__Handler__Issues - Custom path handler for issue tracking file structure
+# Generates paths like: {Issue-NNN}.json, issues.json, labels.json
+# ═══════════════════════════════════════════════════════════════════════════════
+
+
+from osbot_utils.utils.Files                                                        import path_combine_safe
+from osbot_utils.type_safe.Type_Safe                                                import Type_Safe
+from osbot_utils.type_safe.type_safe_core.decorators.type_safe                      import type_safe
+from osbot_utils.type_safe.primitives.domains.files.safe_str.Safe_Str__File__Name   import Safe_Str__File__Name
+from osbot_utils.type_safe.primitives.domains.files.safe_str.Safe_Str__File__Path   import Safe_Str__File__Path
+from issues_fs.schemas.safe_str.Safe_Str__Issue_Id import Safe_Str__Issue_Id
+
+
+class Path__Handler__Issues(Type_Safe):                                          # Path handler for issues
+    base_path : Safe_Str__File__Path                                             # Optional prefix (empty for root)
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Issue Paths
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def path_for_issue(self,
+                       issue_id: Safe_Str__Issue_Id
+                  ) -> Safe_Str__File__Path:          # Path to issue JSON file
+        if self.base_path:
+            return path_combine_safe(self.base_path, f"{issue_id}.json")
+        return f"{issue_id}.json"
+
+    @type_safe
+    def path_for_issues_index(self) -> Safe_Str__File__Path:                                 # Path to issues.json index
+        if self.base_path:
+            return f"{self.base_path}/issues.json"
+        return "issues.json"
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Label Paths
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def path_for_labels(self) -> Safe_Str__File__Path:                                       # Path to labels.json
+        if self.base_path:
+            return path_combine_safe(self.base_path, "labels.json")
+        return "labels.json"
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Attachment Paths (for future use)
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def path_for_attachment(self                              ,                  # Path to attachment file
+                            issue_id : Safe_Str__Issue_Id     ,
+                            filename : Safe_Str__File__Name
+                       ) -> Safe_Str__File__Path:
+        if self.base_path:
+            return path_combine_safe(self.base_path,f"attachments/{issue_id}/{filename}")
+        return f"attachments/{issue_id}/{filename}"

issues_fs/issues/storage/__init__.py

@@ -0,0 +1,3 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Storage package - Memory-FS based storage abstraction for issue tracking
+# ═══════════════════════════════════════════════════════════════════════════════

issues_fs/schemas/enums/Enum__Comment__Author.py

@@ -0,0 +1,10 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Enum__Comment__Author - Comment author enumeration
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from enum                                                                       import Enum
+
+
+class Enum__Comment__Author(str, Enum):                                          # Comment author values
+    HUMAN       = "human"
+    CLAUDE_CODE = "claude-code"

issues_fs/schemas/enums/Enum__Graph__Storage__Backend.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class Enum__Graph__Storage__Backend(str, Enum):                                  # Available storage backends
+    MEMORY     = "memory"                                                        # In-memory (tests)
+    LOCAL_DISK = "local_disk"                                                    # Local file system
+    SQLITE     = "sqlite"                                                        # SQLite database
+    ZIP        = "zip"                                                           # ZIP archive

issues_fs/schemas/enums/Enum__Issue__Status.py

@@ -0,0 +1,13 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Enum__Issue__Status - Issue status enumeration
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from enum                                                                       import Enum
+
+
+class Enum__Issue__Status(str, Enum):                                            # Issue status values
+    BACKLOG     = "backlog"
+    TODO        = "todo"
+    IN_PROGRESS = "in-progress"
+    REVIEW      = "review"
+    DONE        = "done"

issues_fs/schemas/enums/__init__.py

@@ -0,0 +1,3 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Issue tracking schemas package
+# ═══════════════════════════════════════════════════════════════════════════════

issues_fs/schemas/graph/Safe_Str__Graph_Types.py

@@ -0,0 +1,63 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Safe String Types for Graph-Based Issue Tracking
+# Type-safe primitives for node types, labels, statuses, and verbs
+# ═══════════════════════════════════════════════════════════════════════════════
+
+import re
+from osbot_utils.type_safe.primitives.core.Safe_Str                             import Safe_Str
+from osbot_utils.type_safe.primitives.core.enums.Enum__Safe_Str__Regex_Mode     import Enum__Safe_Str__Regex_Mode
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Safe_Str__Node_Type - Node type identifier (bug, task, feature, person, etc.)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class Safe_Str__Node_Type(Safe_Str):                                             # Node type like "bug", "task"
+    max_length        = 50
+    regex             = re.compile(r'^[a-z][a-z0-9-]*$')                         # lowercase, hyphens allowed
+    regex_mode        = Enum__Safe_Str__Regex_Mode.MATCH
+    strict_validation = True
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Safe_Str__Node_Label - Human-readable node label (Bug-27, Task-15)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class Safe_Str__Node_Label(Safe_Str):                                            # Node label like "Bug-27"
+    max_length        = 100
+    regex             = re.compile(r'^[A-Z][a-zA-Z]*-\d{1,5}$')                  # PascalCase-N (e.g., UserStory-1)
+    regex_mode        = Enum__Safe_Str__Regex_Mode.MATCH
+    strict_validation = True
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Safe_Str__Status - Status identifier (backlog, in-progress, done, etc.)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class Safe_Str__Status(Safe_Str):                                                # Status like "in-progress"
+    max_length        = 50
+    regex             = re.compile(r'^[a-z][a-z0-9-]*$')                         # lowercase, hyphens allowed
+    regex_mode        = Enum__Safe_Str__Regex_Mode.MATCH
+    strict_validation = True
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Safe_Str__Link_Verb - Relationship verb (blocks, has-task, assigned-to)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class Safe_Str__Link_Verb(Safe_Str):                                             # Link verb like "blocks"
+    max_length        = 50
+    regex             = re.compile(r'^[a-z][a-z0-9-]*$')                         # lowercase, hyphens allowed
+    regex_mode        = Enum__Safe_Str__Regex_Mode.MATCH
+    strict_validation = True
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Safe_Str__Node_Type_Display - Display name for node type (Bug, Task, Feature)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class Safe_Str__Node_Type_Display(Safe_Str):                                     # Display name like "Bug"
+    max_length        = 100
+    regex             = re.compile(r'^[A-Z][a-zA-Z0-9 ]*$')                      # Title case, spaces allowed
+    regex_mode        = Enum__Safe_Str__Regex_Mode.MATCH
+    strict_validation = True