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

issues_fs/issues/graph_services/Node__Service.py

@@ -0,0 +1,392 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Node__Service - Business logic for node operations
+# Handles create, update, delete, and query operations for graph nodes
+# ═══════════════════════════════════════════════════════════════════════════════
+
+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.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.graph.Schema__Global__Index                     import Schema__Global__Index
+from issues_fs.schemas.graph.Schema__Graph__Link import Schema__Graph__Link
+from issues_fs.schemas.graph.Schema__Graph__Node import Schema__Graph__Node
+from issues_fs.schemas.graph.Schema__Graph__Response import Schema__Graph__Response
+from issues_fs.schemas.graph.Schema__Node                              import Schema__Node
+from issues_fs.schemas.graph.Schema__Node__Create__Request             import Schema__Node__Create__Request
+from issues_fs.schemas.graph.Schema__Node__Create__Response            import Schema__Node__Create__Response
+from issues_fs.schemas.graph.Schema__Node__Delete__Response            import Schema__Node__Delete__Response
+from issues_fs.schemas.graph.Schema__Node__Link import Schema__Node__Link
+from issues_fs.schemas.graph.Schema__Node__List__Response              import Schema__Node__List__Response
+from issues_fs.schemas.graph.Schema__Node__Summary                     import Schema__Node__Summary
+from issues_fs.schemas.graph.Schema__Node__Update__Request             import Schema__Node__Update__Request
+from issues_fs.schemas.graph.Schema__Node__Update__Response            import Schema__Node__Update__Response
+from issues_fs.schemas.graph.Schema__Type__Summary                     import Schema__Type__Summary
+from issues_fs.issues.graph_services.Graph__Repository         import Graph__Repository
+
+# todo: refactor to Issue__Node__Service
+class Node__Service(Type_Safe):                                                  # Node business logic service
+    repository : Graph__Repository                                               # Data access layer
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Query Operations
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def get_node(self                              ,                             # Get single node by label
+                 node_type : Safe_Str__Node_Type   ,
+                 label     : Safe_Str__Node_Label
+            ) -> Optional[Schema__Node]:
+        return self.repository.node_load(node_type = node_type ,
+                                         label     = label     )
+
+    def node_exists(self                              ,                          # Check if node exists
+                    node_type : Safe_Str__Node_Type   ,
+                    label     : Safe_Str__Node_Label
+               ) -> bool:
+        return self.repository.node_exists(node_type = node_type ,
+                                           label     = label     )
+
+    def list_nodes(self                                       ,                  # List nodes, optionally filtered by type
+                   node_type : Safe_Str__Node_Type = None
+              ) -> Schema__Node__List__Response:
+        summaries = []
+
+        if node_type:                                                            # List nodes of specific type
+            summaries = self.list_nodes_for_type(node_type)
+        else:                                                                    # List all nodes across all types
+            node_types = self.repository.node_types_load()
+            for nt in node_types:
+                type_summaries = self.list_nodes_for_type(nt.name)
+                summaries.extend(type_summaries)
+
+        return Schema__Node__List__Response(success = True           ,
+                                            nodes   = summaries      ,
+                                            total   = len(summaries) )
+
+    def list_nodes_for_type(self                              ,                  # List nodes for a specific type
+                            node_type : Safe_Str__Node_Type
+                       ) -> List[Schema__Node__Summary]:
+        summaries = []
+        labels    = self.repository.nodes_list_labels(node_type)
+
+        for label in labels:
+            node = self.repository.node_load(node_type = node_type ,
+                                             label     = label     )
+            if node:
+                summary = Schema__Node__Summary(label     = node.label     ,
+                                                node_type = node.node_type ,
+                                                title     = node.title     ,
+                                                status    = node.status    )
+                summaries.append(summary)
+
+        return summaries
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Create Operations
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def create_node(self                                       ,                 # Create new node
+                    request : Schema__Node__Create__Request
+               ) -> Schema__Node__Create__Response:
+        # Validate title is not empty
+        if str(request.title).strip() == '':
+            return Schema__Node__Create__Response(success = False               ,
+                                                  message = 'Title is required' )
+
+        # Validate node type exists
+        node_types = self.repository.node_types_load()
+        node_type_def = None
+        for nt in node_types:
+            if str(nt.name) == str(request.node_type):
+                node_type_def = nt
+                break
+
+        if node_type_def is None:
+            return Schema__Node__Create__Response(success = False                              ,
+                                                  message = f'Unknown node type: {request.node_type}')
+
+        # Get next index for this type
+        type_index = self.repository.type_index_load(request.node_type)
+        next_num   = int(type_index.next_index)
+        label      = self.label_from_type_and_index(request.node_type, next_num)
+
+        # SAFETY CHECK: If label already exists, find actual next available index
+        while self.repository.node_exists(node_type=request.node_type, label=label):
+            next_num += 1
+            label = self.label_from_type_and_index(request.node_type, next_num)
+
+        now = Timestamp_Now()
+
+        # Determine status
+        status = request.status if request.status else node_type_def.default_status
+
+        # Create node
+        node = Schema__Node(node_id     = Obj_Id()                               ,
+                            node_type   = request.node_type                      ,
+                            node_index  = Safe_UInt(next_num)                    ,
+                            label       = label                                  ,
+                            title       = request.title                          ,
+                            description = request.description                    ,
+                            status      = status                                 ,
+                            created_at  = now                                    ,
+                            updated_at  = now                                    ,
+                            created_by  = Obj_Id()                               ,  # TODO: actual creator
+                            tags        = list(request.tags) if request.tags else [],
+                            links       = []                                     ,
+                            properties  = dict(request.properties) if request.properties else {})
+
+        # Save node
+        if self.repository.node_save(node) is False:
+            return Schema__Node__Create__Response(success = False               ,
+                                                  message = 'Failed to save node')
+
+        # Update type index
+        type_index.next_index   = Safe_UInt(next_num + 1)
+        type_index.count        = Safe_UInt(int(type_index.count) + 1)
+        type_index.last_updated = now
+        self.repository.type_index_save(type_index)
+
+        # Update global index
+        self.update_global_index()
+
+        return Schema__Node__Create__Response(success = True ,
+                                              node    = node )
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Update Operations
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def update_node(self                              ,                          # Update existing node
+                    node_type : Safe_Str__Node_Type   ,
+                    label     : Safe_Str__Node_Label  ,
+                    request   : Schema__Node__Update__Request
+               ) -> Schema__Node__Update__Response:
+        node = self.repository.node_load(node_type = node_type ,
+                                         label     = label     )
+        if node is None:
+            return Schema__Node__Update__Response(success = False                    ,
+                                                  message = f'Node not found: {label}')
+
+        # Apply updates - use truthiness check because Type_Safe auto-initializes
+        # empty strings for Safe_Str types (so `is not None` doesn't work)
+        if request.title:                                                        # Only update if non-empty
+            node.title = request.title
+        if request.description:                                                  # Only update if non-empty
+            node.description = request.description
+        if request.status:                                                       # Only update if non-empty
+            node.status = request.status
+        if request.tags is not None:                                             # Tags can be empty list
+            node.tags = list(request.tags)
+        if request.properties is not None:                                       # Deep merge properties
+            node.properties = self.deep_merge_properties(node.properties, request.properties)
+
+        node.updated_at = Timestamp_Now()
+
+        # Save
+        if self.repository.node_save(node) is False:
+            return Schema__Node__Update__Response(success = False                 ,
+                                                  message = 'Failed to save node' )
+
+        return Schema__Node__Update__Response(success = True ,
+                                              node    = node )
+
+    def deep_merge_properties(self                  ,                            # Deep merge properties dicts
+                              existing : dict       ,
+                              updates  : dict
+                         ) -> dict:
+        result = dict(existing) if existing else {}                              # Copy existing properties
+
+        for key, value in updates.items():
+            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                result[key] = self.deep_merge_properties(result[key], value)     # Recursively merge nested dicts
+            else:
+                result[key] = value                                              # Replace or add key
+
+        return result
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Delete Operations
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def delete_node(self                              ,                          # Delete node
+                    node_type : Safe_Str__Node_Type   ,
+                    label     : Safe_Str__Node_Label
+               ) -> Schema__Node__Delete__Response:
+        if self.repository.node_exists(node_type, label) is False:
+            return Schema__Node__Delete__Response(success = False                     ,
+                                                  deleted = False                     ,
+                                                  label   = label                     ,
+                                                  message = f'Node not found: {label}')
+
+        # TODO: Remove links from other nodes pointing to this one
+
+        # Delete node
+        if self.repository.node_delete(node_type, label) is False:
+            return Schema__Node__Delete__Response(success = False                   ,
+                                                  deleted = False                   ,
+                                                  label   = label                   ,
+                                                  message = 'Failed to delete node' )
+
+        # Update type index
+        type_index = self.repository.type_index_load(node_type)
+        type_index.count = Safe_UInt(max(0, int(type_index.count) - 1))
+        type_index.last_updated = Timestamp_Now()
+        self.repository.type_index_save(type_index)
+
+        # Update global index
+        self.update_global_index()
+
+        return Schema__Node__Delete__Response(success = True  ,
+                                              deleted = True  ,
+                                              label   = label )
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Helper Methods
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def label_from_type_and_index(self                              ,            # Generate label
+                                  node_type  : Safe_Str__Node_Type  ,
+                                  node_index : int
+                             ) -> Safe_Str__Node_Label:
+        display_type = str(node_type).capitalize()
+        return Safe_Str__Node_Label(f"{display_type}-{node_index}")
+
+    def update_global_index(self) -> None:                                       # Recalculate global index
+        node_types   = self.repository.node_types_load()
+        total_nodes  = 0
+        type_counts  = []
+
+        for nt in node_types:
+            type_index = self.repository.type_index_load(nt.name)
+            count      = int(type_index.count)
+            total_nodes += count
+            type_counts.append(Schema__Type__Summary(node_type = nt.name          ,
+                                                     count     = Safe_UInt(count) ))
+
+        global_index = Schema__Global__Index(total_nodes  = Safe_UInt(total_nodes) ,
+                                             last_updated = Timestamp_Now()        ,
+                                             type_counts  = type_counts            )
+
+        self.repository.global_index_save(global_index)
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Graph Traversal Operations
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def get_node_graph(self                              ,                       # Get node with connected nodes
+                       node_type : Safe_Str__Node_Type   ,
+                       label     : Safe_Str__Node_Label  ,
+                       depth     : int = 1
+                  ) -> 'Schema__Graph__Response':
+
+        if depth > 3:                                                            # Cap depth to prevent expensive traversals
+            depth = 3
+
+        root_node = self.repository.node_load(node_type = node_type ,
+                                              label     = label     )
+        if root_node is None:
+            return Schema__Graph__Response(success = False              ,
+                                           root    = label              ,
+                                           nodes   = []                 ,
+                                           links   = []                 ,
+                                           depth   = depth              ,
+                                           message = f'Node not found: {label}')
+
+        visited_labels = set()
+        nodes          = []
+        links          = []
+
+        self._traverse_graph(root_node, depth, visited_labels, nodes, links)
+
+        return Schema__Graph__Response(success = True   ,
+                                       root    = label  ,
+                                       nodes   = nodes  ,
+                                       links   = links  ,
+                                       depth   = depth  )
+
+    def _traverse_graph(self                       ,                             # Recursively traverse graph
+                        node    : Schema__Node     ,
+                        depth   : int              ,
+                        visited : set              ,
+                        nodes   : list             ,
+                        links   : list
+                   ) -> None:
+
+        label_str = str(node.label)
+        if label_str in visited or depth < 0:
+            return
+
+        visited.add(label_str)
+        nodes.append(Schema__Graph__Node(label     = node.label     ,
+                                         title     = node.title     ,
+                                         node_type = node.node_type ,
+                                         status    = node.status    ))
+
+        if depth == 0:
+            return
+
+        # Traverse outgoing links
+        if node.links:
+            for link in node.links:
+                target_label = link.target_label
+                if target_label and str(target_label) not in visited:
+                    target_node = self._resolve_link_target(link)
+                    if target_node:
+                        links.append(Schema__Graph__Link(source    = node.label      ,
+                                                         target    = target_node.label,
+                                                         link_type = link.verb))
+                        self._traverse_graph(target_node, depth - 1, visited, nodes, links)
+
+        # Find and traverse incoming links
+        incoming = self._find_incoming_links(node.label)
+        for source_node, link_type in incoming:
+            if str(source_node.label) not in visited:
+                links.append(Schema__Graph__Link(source    = source_node.label ,
+                                                 target    = node.label        ,
+                                                 link_type = link_type         ))
+                self._traverse_graph(source_node, depth - 1, visited, nodes, links)
+
+    def _resolve_link_target(self                           ,                    # Load target node from link
+                             link : Schema__Node__Link
+                        ) -> Schema__Node:
+        if not link.target_label:
+            return None
+
+        target_label = str(link.target_label)
+        parts        = target_label.split('-')                                   # Parse "Bug-1" -> type="bug", label="Bug-1"
+
+        if len(parts) != 2:
+            return None
+
+        target_type = parts[0].lower()                                           # "Bug" -> "bug"
+
+        try:
+            return self.repository.node_load(node_type = Safe_Str__Node_Type(target_type)  ,
+                                             label     = Safe_Str__Node_Label(target_label))
+        except Exception:
+            return None
+
+    # todo: this should not be a tuple, this should be a Type_Safe class
+    def _find_incoming_links(self                              ,                 # Find nodes that link TO this node
+                             label : Safe_Str__Node_Label
+                        ) -> List[tuple]:
+        incoming    = []
+        label_str   = str(label)
+        node_types  = self.repository.node_types_load()
+
+        for nt in node_types:
+            labels = self.repository.nodes_list_labels(nt.name)
+            for node_label in labels:
+                if str(node_label) == label_str:                                 # Skip self
+                    continue
+
+                node = self.repository.node_load(node_type = nt.name   ,
+                                                 label     = node_label)
+                if node and node.links:
+                    for link in node.links:
+                        if link.target_label and str(link.target_label) == label_str:
+                            incoming.append((node, str(link.verb)))
+                            break                                                # Only add node once
+
+        return incoming

issues_fs/issues/graph_services/Type__Service.py

@@ -0,0 +1,209 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Type__Service - Business logic for type definitions
+# Manages node types (bug, task, feature) and link types (blocks, has-task)
+# Phase 1: Added git-repo type for root issue support
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from typing                                                                                             import List, Optional
+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 osbot_utils.type_safe.primitives.domains.identifiers.Obj_Id                                        import Obj_Id
+from osbot_utils.type_safe.type_safe_core.decorators.type_safe                                          import type_safe
+
+from issues_fs.schemas.graph.Safe_Str__Graph_Types                     import Safe_Str__Node_Type, Safe_Str__Status, Safe_Str__Node_Type_Display, Safe_Str__Link_Verb
+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.safe_str.Safe_Str__Hex_Color                    import Safe_Str__Hex_Color
+from issues_fs.issues.graph_services.Graph__Repository         import Graph__Repository
+
+
+class Type__Service(Type_Safe):                                                  # Type definition service
+    repository : Graph__Repository                                               # Data access layer
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Node Type Operations
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def list_node_types(self) -> List[Schema__Node__Type]:                       # Get all node types
+        return self.repository.node_types_load()
+
+    def get_node_type(self                         ,                             # Get single node type
+                      name : Safe_Str__Node_Type
+                 ) -> Schema__Node__Type:
+        types = self.repository.node_types_load()
+        for t in types:
+            if str(t.name) == str(name):
+                return t
+        return None
+
+    @type_safe
+    def create_node_type(self                                                       ,                  # Create new node type
+                         name           : Safe_Str__Node_Type                       ,
+                         display_name   : Safe_Str__Node_Type_Display               ,
+                         description    : Safe_Str__Text                 = ''       ,
+                         color          : Safe_Str__Hex_Color            = '#888888',
+                         statuses       : List[str]                      = None     ,
+                         default_status : Safe_Str__Status               = 'backlog'
+                    ) -> Schema__Node__Type:
+        types = self.repository.node_types_load()
+
+        for t in types:
+            if t.name == name:
+                return None                                                      # Already exists
+
+        status_list = statuses or ['backlog', 'in-progress', 'done']
+
+        node_type = Schema__Node__Type(type_id        = Obj_Id()       ,
+                                       name           = name           ,
+                                       display_name   = display_name   ,
+                                       description    = description    ,
+                                       color          = color          ,
+                                       statuses       = status_list    ,
+                                       default_status = default_status )
+
+        types.append(node_type)
+        self.repository.node_types_save(types)
+        return node_type
+
+    def delete_node_type(self                         ,                          # Delete node type
+                         name : Safe_Str__Node_Type
+                    ) -> bool:
+        types = self.repository.node_types_load()
+
+        type_index = self.repository.type_index_load(name)                       # Check if any nodes of this type exist
+        if int(type_index.count) > 0:
+            return False                                                         # Cannot delete type with existing nodes
+
+        types = [t for t in types if str(t.name) != str(name)]                   # Remove type
+        self.repository.node_types_save(types)
+        return True
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Link Type Operations
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    @type_safe
+    def list_link_types(self) -> List[Schema__Link__Type]:                       # Get all link types
+        return self.repository.link_types_load()
+
+    def get_link_type(self                         ,                             # Get link type by verb
+                      verb : Safe_Str__Link_Verb
+                 ) -> Optional[Schema__Link__Type]:
+        types = self.repository.link_types_load()
+        for t in types:
+            if str(t.verb) == str(verb):
+                return t
+        return None
+
+    @type_safe
+    def create_link_type(self                                 ,                  # Create new link type
+                         verb          : Safe_Str__Link_Verb  ,
+                         inverse_verb  : Safe_Str__Link_Verb                  ,
+                         description   : Safe_Str__Text             = ''      ,
+                         source_types  : List[Safe_Str__Node_Type]  = None    ,
+                         target_types  : List[Safe_Str__Node_Type]  = None
+                    ) -> Schema__Link__Type:
+        types = self.repository.link_types_load()
+
+        for t in types:
+            if str(t.verb) == str(verb):
+                return None                                                      # Already exists
+
+        link_type = Schema__Link__Type(link_type_id = Obj_Id()      ,
+                                       verb         = verb          ,
+                                       inverse_verb = inverse_verb  ,
+                                       description  = description   ,
+                                       source_types = source_types  ,
+                                       target_types = target_types  )
+
+        types.append(link_type)
+        self.repository.link_types_save(types)
+        return link_type
+
+    # ═══════════════════════════════════════════════════════════════════════════════
+    # Default Type Initialization
+    # ═══════════════════════════════════════════════════════════════════════════════
+
+    def initialize_default_types(self) -> None:                                  # Set up default types
+        if len(self.repository.node_types_load()) > 0:                           # Check if already initialized
+            return
+
+        # ───────────────────────────────────────────────────────────────────────────
+        # Node Types
+        # ───────────────────────────────────────────────────────────────────────────
+
+        self.create_node_type(name           = Safe_Str__Node_Type('git-repo')     ,  # NEW: Root issue type for git repositories
+                              display_name   = 'GitRepo'                           ,
+                              description    = 'Git repository root - contains all issues',
+                              color          = '#6366f1'                           ,  # Indigo color
+                              statuses       = ['active', 'archived']              ,
+                              default_status = 'active'                            )
+
+        self.create_node_type(name           = Safe_Str__Node_Type('bug')          ,
+                              display_name   = 'Bug'                               ,
+                              description    = 'Defect or error in the system'     ,
+                              color          = '#ef4444'                           ,
+                              statuses       = ['backlog', 'confirmed', 'in-progress', 'testing', 'resolved', 'closed'],
+                              default_status = 'backlog'                           )
+
+        self.create_node_type(name           = Safe_Str__Node_Type('task')         ,
+                              display_name   = 'Task'                              ,
+                              description    = 'Unit of work to be completed'      ,
+                              color          = '#3b82f6'                           ,
+                              statuses       = ['backlog', 'todo', 'in-progress', 'review', 'done'],
+                              default_status = 'backlog'                           )
+
+        self.create_node_type(name           = Safe_Str__Node_Type('feature')      ,
+                              display_name   = 'Feature'                           ,
+                              description    = 'High-level capability'             ,
+                              color          = '#22c55e'                           ,
+                              statuses       = ['proposed', 'approved', 'in-progress', 'released'],
+                              default_status = 'proposed'                          )
+
+        self.create_node_type(name           = Safe_Str__Node_Type('person')       ,
+                              display_name   = 'Person'                            ,
+                              description    = 'Human or agent identity'           ,
+                              color          = '#8b5cf6'                           ,
+                              statuses       = ['active', 'inactive']              ,
+                              default_status = 'active'                            )
+
+        # ───────────────────────────────────────────────────────────────────────────
+        # Link Types
+        # ───────────────────────────────────────────────────────────────────────────
+
+        self.create_link_type(verb         = Safe_Str__Link_Verb('blocks')          ,
+                              inverse_verb = 'blocked-by'                           ,
+                              description  = 'Prevents progress on target'          ,
+                              source_types = ['bug', 'task']                        ,
+                              target_types = ['task', 'feature']                    )
+
+        self.create_link_type(verb         = Safe_Str__Link_Verb('has-task')        ,
+                              inverse_verb = 'task-of'                              ,
+                              description  = 'Contains as sub-work'                 ,
+                              source_types = ['feature', 'git-repo']                ,  # git-repo can have tasks
+                              target_types = ['task']                               )
+
+        self.create_link_type(verb         = Safe_Str__Link_Verb('assigned-to')     ,
+                              inverse_verb = 'assignee-of'                          ,
+                              description  = 'Work assigned to person/agent'        ,
+                              source_types = ['bug', 'task', 'feature']             ,
+                              target_types = ['person']                             )
+
+        self.create_link_type(verb         = Safe_Str__Link_Verb('depends-on')      ,
+                              inverse_verb = 'dependency-of'                        ,
+                              description  = 'Requires target to complete first'    ,
+                              source_types = ['task', 'feature']                    ,
+                              target_types = ['task', 'feature']                    )
+
+        self.create_link_type(verb         = Safe_Str__Link_Verb('relates-to')      ,
+                              inverse_verb = 'relates-to'                           ,
+                              description  = 'General association (symmetric)'      ,
+                              source_types = ['bug', 'task', 'feature', 'git-repo'] ,
+                              target_types = ['bug', 'task', 'feature', 'git-repo'] )
+
+        self.create_link_type(verb         = Safe_Str__Link_Verb('contains')        ,  # NEW: For hierarchical structure
+                              inverse_verb = 'contained-by'                         ,
+                              description  = 'Parent contains child issue'          ,
+                              source_types = ['git-repo', 'feature', 'task']        ,
+                              target_types = ['bug', 'task', 'feature']             )

issues_fs/issues/graph_services/__init__.py

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