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

issues_fs/issues/Issue__Path__Config.py

@@ -0,0 +1,25 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Issue__Path__Config - Configuration for issue tracking paths
+# Provides the default issues directory path based on project structure
+# ═══════════════════════════════════════════════════════════════════════════════
+import issues_fs
+from osbot_utils.type_safe.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.utils.Files                                                      import path_combine, folder_exists, folder_create
+
+
+class Issue__Path__Config(Type_Safe):                                            # Issue path configuration
+
+    @classmethod
+    def default_issues_path(cls) -> Safe_Str__File__Path:                                    # Get default issues directory
+        root_path   = issues_fs.path
+        issues_path = path_combine(root_path, '../docs/dev-briefs/issues')
+        return issues_path
+
+    @classmethod
+    def ensure_issues_directory(cls, path: Safe_Str__File__Path = None) -> Safe_Str__File__Path:         # Create issues directory if needed
+        if path is None:
+            path = cls.default_issues_path()
+        if folder_exists(path) is False:
+            folder_create(path)
+        return path

issues_fs/issues/__init__.py

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

issues_fs/issues/graph_services/Comments__Service.py

@@ -0,0 +1,235 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Comments__Service - Business logic for comment CRUD operations
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from typing                                                                                         import List
+from osbot_utils.type_safe.Type_Safe                                                                import Type_Safe
+from osbot_utils.type_safe.primitives.domains.identifiers.Obj_Id                                    import Obj_Id
+from osbot_utils.type_safe.primitives.domains.identifiers.safe_int.Timestamp_Now                    import Timestamp_Now
+from issues_fs.schemas.graph.Safe_Str__Graph_Types                 import Safe_Str__Node_Type, Safe_Str__Node_Label
+from issues_fs.schemas.issues.Schema__Comment                      import Schema__Comment__List__Response, Schema__Comment__Create__Request, Schema__Comment__Response, Schema__Comment, Schema__Comment__Update__Request, Schema__Comment__Delete__Response
+from issues_fs.issues.graph_services.Graph__Repository     import Graph__Repository
+
+
+class Comments__Service(Type_Safe):                                              # Comment business logic service
+    repository : Graph__Repository = None                                                   # Graph__Repository instance
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # List Comments
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def list_comments(self                              ,                        # List all comments on a node
+                      node_type : Safe_Str__Node_Type   ,
+                      label     : Safe_Str__Node_Label
+                 ) -> Schema__Comment__List__Response:
+        node = self.repository.node_load(node_type = node_type ,
+                                         label     = label     )
+        if node is None:
+            return Schema__Comment__List__Response(success  = False                     ,
+                                                   comments = []                        ,
+                                                   total    = 0                         ,
+                                                   message  = f'Node not found: {label}')
+
+        raw_comments = node.properties.get('comments', []) if node.properties else []
+        comments     = self._parse_comments(raw_comments)
+
+        return Schema__Comment__List__Response(success  = True          ,
+                                               comments = comments      ,
+                                               total    = len(comments) )
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Create Comment
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def create_comment(self                                    ,                 # Add comment to node
+                       node_type : Safe_Str__Node_Type         ,
+                       label     : Safe_Str__Node_Label        ,
+                       request   : Schema__Comment__Create__Request
+                  ) -> Schema__Comment__Response:
+        # Validate request
+        if not request.text or str(request.text).strip() == '':
+            return Schema__Comment__Response(success = False                    ,
+                                             message = 'Comment text is required')
+
+        if not request.author or str(request.author).strip() == '':
+            return Schema__Comment__Response(success = False                   ,
+                                             message = 'Author is required'    )
+
+        # Load node
+        node = self.repository.node_load(node_type = node_type ,
+                                         label     = label     )
+        if node is None:
+            return Schema__Comment__Response(success = False                     ,
+                                             message = f'Node not found: {label}')
+
+        # Create comment with server-generated ID and timestamp
+        now     = Timestamp_Now()
+        comment = Schema__Comment(id         = Obj_Id()       ,
+                                  author     = request.author ,
+                                  text       = request.text   ,
+                                  created_at = now            ,
+                                  updated_at = now            )
+
+        # Add to node properties
+        if node.properties is None:
+            node.properties = {}
+        if 'comments' not in node.properties:
+            node.properties['comments'] = []
+
+        node.properties['comments'].append(comment.json())
+        node.updated_at = now
+
+        # Save node
+        if self.repository.node_save(node) is False:
+            return Schema__Comment__Response(success = False                  ,
+                                             message = 'Failed to save node'  )
+
+        return Schema__Comment__Response(success = True    ,
+                                         comment = comment )
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Get Single Comment
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def get_comment(self                              ,                          # Get single comment by ID
+                    node_type  : Safe_Str__Node_Type  ,
+                    label      : Safe_Str__Node_Label ,
+                    comment_id : str
+               ) -> Schema__Comment__Response:
+        node = self.repository.node_load(node_type = node_type ,
+                                         label     = label     )
+        if node is None:
+            return Schema__Comment__Response(success = False                     ,
+                                             message = f'Node not found: {label}')
+
+        raw_comments = node.properties.get('comments', []) if node.properties else []
+
+        for raw in raw_comments:
+            if raw.get('id') == comment_id:
+                comment = self._parse_comment(raw)
+                return Schema__Comment__Response(success = True    ,
+                                                 comment = comment )
+
+        return Schema__Comment__Response(success = False                              ,
+                                         message = f'Comment not found: {comment_id}')
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Update Comment
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def update_comment(self                                    ,                 # Edit comment text
+                       node_type  : Safe_Str__Node_Type        ,
+                       label      : Safe_Str__Node_Label       ,
+                       comment_id : str                        ,
+                       request    : Schema__Comment__Update__Request
+                  ) -> Schema__Comment__Response:
+        # Validate request
+        if not request.text or str(request.text).strip() == '':
+            return Schema__Comment__Response(success = False                     ,
+                                             message = 'Comment text is required')
+
+        # Load node
+        node = self.repository.node_load(node_type = node_type ,
+                                         label     = label     )
+        if node is None:
+            return Schema__Comment__Response(success = False                     ,
+                                             message = f'Node not found: {label}')
+
+        raw_comments = node.properties.get('comments', []) if node.properties else []
+
+        # Find and update comment
+        found   = False
+        updated = None
+        now     = Timestamp_Now()
+
+        for raw in raw_comments:
+            if raw.get('id') == comment_id:
+                raw['text']       = str(request.text)
+                raw['updated_at'] = int(now)
+                updated           = self._parse_comment(raw)
+                found             = True
+                break
+
+        if not found:
+            return Schema__Comment__Response(success = False                              ,
+                                             message = f'Comment not found: {comment_id}')
+
+        # Save node
+        node.properties['comments'] = raw_comments
+        node.updated_at             = now
+
+        if self.repository.node_save(node) is False:
+            return Schema__Comment__Response(success = False                 ,
+                                             message = 'Failed to save node' )
+
+        return Schema__Comment__Response(success = True    ,
+                                         comment = updated )
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Delete Comment
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def delete_comment(self                              ,                       # Remove comment from node
+                       node_type  : Safe_Str__Node_Type  ,
+                       label      : Safe_Str__Node_Label ,
+                       comment_id : str
+                  ) -> Schema__Comment__Delete__Response:
+        # Load node
+        node = self.repository.node_load(node_type = node_type ,
+                                         label     = label     )
+        if node is None:
+            return Schema__Comment__Delete__Response(success    = False                     ,
+                                                     deleted    = False                     ,
+                                                     comment_id = comment_id                ,
+                                                     message    = f'Node not found: {label}')
+
+        raw_comments = node.properties.get('comments', []) if node.properties else []
+        original_len = len(raw_comments)
+
+        # Filter out the comment to delete
+        raw_comments = [c for c in raw_comments if c.get('id') != comment_id]
+
+        if len(raw_comments) == original_len:
+            return Schema__Comment__Delete__Response(success    = False                              ,
+                                                     deleted    = False                              ,
+                                                     comment_id = comment_id                         ,
+                                                     message    = f'Comment not found: {comment_id}')
+
+        # Save node
+        node.properties['comments'] = raw_comments
+        node.updated_at             = Timestamp_Now()
+
+        if self.repository.node_save(node) is False:
+            return Schema__Comment__Delete__Response(success    = False                 ,
+                                                     deleted    = False                 ,
+                                                     comment_id = comment_id            ,
+                                                     message    = 'Failed to save node' )
+
+        return Schema__Comment__Delete__Response(success    = True       ,
+                                                 deleted    = True       ,
+                                                 comment_id = comment_id )
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Helper Methods
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def _parse_comments(self, raw_comments: list) -> List[Schema__Comment]:      # Parse raw dicts to Schema__Comment
+        comments = []
+        for raw in raw_comments:
+            comment = self._parse_comment(raw)
+            if comment:
+                comments.append(comment)
+        return comments
+
+    def _parse_comment(self, raw: dict) -> Schema__Comment:                      # Parse single raw dict
+        if not raw:
+            return None
+
+        try:
+            return Schema__Comment(id         = Obj_Id(raw.get('id', str(Obj_Id())))                           ,
+                                   author     = raw.get('author', 'unknown')                                   ,
+                                   text       = raw.get('text', '')                                            ,
+                                   created_at = Timestamp_Now(raw.get('created_at', raw.get('timestamp', 0)))  ,
+                                   updated_at = Timestamp_Now(raw.get('updated_at', raw.get('created_at', 0))) )
+        except Exception:
+            return None

issues_fs/issues/graph_services/Graph__Repository.py

@@ -0,0 +1,307 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Graph__Repository - Memory-FS based data access for graph nodes
+# Storage-agnostic: works with Memory, Local Disk, S3, SQLite, ZIP backends
+#
+# Phase 1 Changes:
+#   - node_load: Reads issue.json first, falls back to node.json
+#   - node_save: Always writes to issue.json (preserves node.json for now)
+#   - node_exists: Checks for either issue.json or node.json
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from typing                                                                                             import List, Optional
+from memory_fs.Memory_FS                                                                                import Memory_FS
+from memory_fs.storage_fs.Storage_FS                                                                    import Storage_FS
+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.utils.Json                                                                             import json_loads, json_dumps
+from issues_fs.schemas.graph.Safe_Str__Graph_Types                     import Safe_Str__Node_Type, Safe_Str__Node_Label
+from issues_fs.schemas.graph.Schema__Global__Index                     import Schema__Global__Index
+from issues_fs.schemas.graph.Schema__Node                              import Schema__Node
+from issues_fs.schemas.graph.Schema__Node__Type                        import Schema__Node__Type
+from issues_fs.schemas.graph.Schema__Link__Type                        import Schema__Link__Type
+from issues_fs.schemas.graph.Schema__Type__Index                       import Schema__Type__Index
+from issues_fs.issues.storage.Path__Handler__Graph_Node        import Path__Handler__Graph_Node
+
+
+class Graph__Repository(Type_Safe):                                              # Memory-FS based graph repository
+    memory_fs    : Memory_FS                                                     # Storage abstraction
+    path_handler : Path__Handler__Graph_Node                                     # Path generation
+    storage_fs   : Storage_FS             = None                                 # Set from memory_fs
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        if self.memory_fs:
+            self.storage_fs = self.memory_fs.storage_fs
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Node Operations - Phase 1: Dual File Support
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def node_save(self, node: Schema__Node) -> bool:                             # Save node to issue.json
+        if not node.label:
+            return False
+
+        path_issue = self.path_handler.path_for_issue_json(node_type = node.node_type,  # Always write to issue.json
+                                                           label     = node.label     )
+        data       = node.json()
+        content    = json_dumps(data, indent=2)
+        return self.storage_fs.file__save(path_issue, content.encode('utf-8'))
+
+    @type_safe
+    def node_load(self                              ,                            # Load node from issue.json or node.json
+                  node_type : Safe_Str__Node_Type   ,
+                  label     : Safe_Str__Node_Label
+             ) -> Schema__Node:
+        path = self.get_issue_file_path(node_type, label)                        # Get actual file path (issue.json or node.json)
+        if path is None:
+            return None
+
+        content = self.storage_fs.file__str(path)
+        if not content:
+            return None
+
+        data = json_loads(content)
+        if data is None:
+            return None
+
+        return Schema__Node.from_json(data)
+
+    @type_safe
+    def node_delete(self                              ,                          # Delete node from storage
+                    node_type : Safe_Str__Node_Type   ,
+                    label     : Safe_Str__Node_Label
+               ) -> bool:
+        deleted_any  = False
+        path_issue   = self.path_handler.path_for_issue_json(node_type, label)   # Delete issue.json if exists
+        path_node    = self.path_handler.path_for_node_json(node_type, label)    # Delete node.json if exists
+
+        if self.storage_fs.file__exists(path_issue):
+            self.storage_fs.file__delete(path_issue)
+            deleted_any = True
+
+        if self.storage_fs.file__exists(path_node):
+            self.storage_fs.file__delete(path_node)
+            deleted_any = True
+
+        return deleted_any
+
+    @type_safe
+    def node_exists(self                              ,                          # Check if node exists (either file)
+                    node_type : Safe_Str__Node_Type   ,
+                    label     : Safe_Str__Node_Label
+               ) -> bool:
+        return self.get_issue_file_path(node_type, label) is not None
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # File Path Resolution - Phase 1: Prefer issue.json over node.json
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def get_issue_file_path(self                              ,                  # Get actual issue file path
+                            node_type : Safe_Str__Node_Type   ,                  # Prefers issue.json, falls back to node.json
+                            label     : Safe_Str__Node_Label
+                       ) -> str:
+        path_issue = self.path_handler.path_for_issue_json(node_type, label)     # Check issue.json first
+        if self.storage_fs.file__exists(path_issue):
+            return path_issue
+
+        path_node = self.path_handler.path_for_node_json(node_type, label)       # Fall back to node.json
+        if self.storage_fs.file__exists(path_node):
+            return path_node
+
+        return None                                                              # Neither exists
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Node Listing Operations
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def nodes_list_labels(self                              ,                    # List all node labels for a type
+                          node_type : Safe_Str__Node_Type
+                     ) -> List[Safe_Str__Node_Label]:
+        type_folder = self.path_handler.path_for_type_folder(node_type)
+        all_paths   = self.storage_fs.files__paths()
+
+        labels = set()                                                           # Use set to avoid duplicates
+        prefix = f"{type_folder}/"
+
+        for path in all_paths:
+            if path.startswith(prefix) is False:
+                continue
+
+            relative = path[len(prefix):]                                        # Remove prefix
+            parts    = relative.split('/')
+
+            if len(parts) >= 2:
+                label    = parts[0]                                              # First part is label folder
+                filename = parts[1]                                              # Second part is filename
+
+                if filename in ('issue.json', 'node.json'):                      # Check for either file
+                    try:
+                        labels.add(Safe_Str__Node_Label(label))
+                    except Exception:
+                        pass                                                     # Skip invalid label formats
+
+        return list(labels)
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Type Index Operations
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def type_index_load(self                              ,                      # Load per-type index
+                        node_type : Safe_Str__Node_Type
+                   ) -> Schema__Type__Index:
+        path = self.path_handler.path_for_type_index(node_type)
+        if self.storage_fs.file__exists(path) is False:
+            return Schema__Type__Index(node_type=node_type)
+
+        content = self.storage_fs.file__str(path)
+        if not content:
+            return Schema__Type__Index(node_type=node_type)
+
+        data = json_loads(content)
+        if data is None:
+            return Schema__Type__Index(node_type=node_type)
+
+        return Schema__Type__Index.from_json(data)
+
+    @type_safe
+    def type_index_save(self                              ,                      # Save per-type index
+                        index : Schema__Type__Index
+                   ) -> bool:
+        path    = self.path_handler.path_for_type_index(index.node_type)
+        data    = index.json()
+        content = json_dumps(data, indent=2)
+        return self.storage_fs.file__save(path, content.encode('utf-8'))
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Global Index Operations
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def global_index_load(self) -> Schema__Global__Index:                        # Load global index
+        path = self.path_handler.path_for_global_index()
+        if self.storage_fs.file__exists(path) is False:
+            return Schema__Global__Index()
+
+        content = self.storage_fs.file__str(path)
+        if not content:
+            return Schema__Global__Index()
+
+        data = json_loads(content)
+        if data is None:
+            return Schema__Global__Index()
+
+        return Schema__Global__Index.from_json(data)
+
+    def global_index_save(self, index: Schema__Global__Index) -> bool:           # Save global index
+        path    = self.path_handler.path_for_global_index()
+        data    = index.json()
+        content = json_dumps(data, indent=2)
+        return self.storage_fs.file__save(path, content.encode('utf-8'))
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Config Operations - Node Types
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def node_types_load(self) -> List[Schema__Node__Type]:                       # Load all node types
+        path = self.path_handler.path_for_node_types()
+        if self.storage_fs.file__exists(path) is False:
+            return []
+
+        content = self.storage_fs.file__str(path)
+        if not content:
+            return []
+
+        data = json_loads(content)
+        if data is None or 'types' not in data:
+            return []
+
+        types = []
+        for item in data['types']:
+            types.append(Schema__Node__Type.from_json(item))
+        return types
+
+    def node_types_save(self, types: List[Schema__Node__Type]) -> bool:          # Save all node types
+        path = self.path_handler.path_for_node_types()
+        data = {'types': [t.json() for t in types]}
+        content = json_dumps(data, indent=2)
+        return self.storage_fs.file__save(path, content.encode('utf-8'))
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Config Operations - Link Types
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def link_types_load(self) -> List[Schema__Link__Type]:                       # Load all link types
+        path = self.path_handler.path_for_link_types()
+        if self.storage_fs.file__exists(path) is False:
+            return []
+
+        content = self.storage_fs.file__str(path)
+        if not content:
+            return []
+
+        data = json_loads(content)
+        if data is None or 'link_types' not in data:
+            return []
+
+        types = []
+        for item in data['link_types']:
+            types.append(Schema__Link__Type.from_json(item))
+        return types
+
+    def link_types_save(self, types: List[Schema__Link__Type]) -> bool:          # Save all link types
+        path = self.path_handler.path_for_link_types()
+        data = {'link_types': [t.json() for t in types]}
+        content = json_dumps(data, indent=2)
+        return self.storage_fs.file__save(path, content.encode('utf-8'))
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Attachment Operations
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def attachment_save(self                              ,                      # Save attachment (raw bytes)
+                        node_type : Safe_Str__Node_Type   ,
+                        label     : Safe_Str__Node_Label  ,
+                        filename  : str                   ,
+                        data      : bytes
+                   ) -> bool:
+        path = self.path_handler.path_for_attachment(node_type = node_type ,
+                                                     label     = label     ,
+                                                     filename  = filename  )
+        return self.storage_fs.file__save(path, data)
+
+    @type_safe
+    def attachment_load(self                              ,                      # Load attachment
+                        node_type : Safe_Str__Node_Type   ,
+                        label     : Safe_Str__Node_Label  ,
+                        filename  : str
+                   ) -> bytes:
+        path = self.path_handler.path_for_attachment(node_type = node_type ,
+                                                     label     = label     ,
+                                                     filename  = filename  )
+        if self.storage_fs.file__exists(path) is False:
+            return None
+        return self.storage_fs.file__bytes(path)
+
+    @type_safe
+    def attachment_delete(self                              ,                    # Delete attachment
+                          node_type : Safe_Str__Node_Type   ,
+                          label     : Safe_Str__Node_Label  ,
+                          filename  : str
+                     ) -> bool:
+        path = self.path_handler.path_for_attachment(node_type = node_type ,
+                                                     label     = label     ,
+                                                     filename  = filename  )
+        if self.storage_fs.file__exists(path):
+            return self.storage_fs.file__delete(path)
+        return False
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Utility Operations
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def clear_storage(self) -> None:                                             # Clear all data (for tests)
+        self.storage_fs.clear()