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

issues_fs/schemas/graph/Schema__Global__Index.py

@@ -0,0 +1,16 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Global__Index - Global index for entire graph
+# Stored at .issues/_index.json - tracks total nodes and per-type counts
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from typing                                                                                  import List
+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.safe_int.Timestamp_Now             import Timestamp_Now
+from issues_fs.schemas.graph.Schema__Type__Summary          import Schema__Type__Summary
+
+
+class Schema__Global__Index(Type_Safe):                                          # Global index file (.issues/_index.json)
+    total_nodes   : Safe_UInt            = Safe_UInt(0)                          # Total nodes across all types
+    last_updated  : Timestamp_Now        = None                                  # ISO timestamp of last update
+    type_counts   : List[Schema__Type__Summary]                                  # Count per type

issues_fs/schemas/graph/Schema__Graph__Link.py

@@ -0,0 +1,8 @@
+from osbot_utils.type_safe.Type_Safe                                                import Type_Safe
+from issues_fs.schemas.graph.Safe_Str__Graph_Types import Safe_Str__Node_Label, Safe_Str__Link_Verb
+
+# todo, see if we shouldn't call 'link_type' 'link_verb'
+class Schema__Graph__Link(Type_Safe):                                            # Link for graph response
+    source    : Safe_Str__Node_Label
+    target    : Safe_Str__Node_Label
+    link_type : Safe_Str__Link_Verb                                              # verb like "has-task", "blocks"

issues_fs/schemas/graph/Schema__Graph__Node.py

@@ -0,0 +1,10 @@
+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.graph.Safe_Str__Graph_Types                 import Safe_Str__Node_Type, Safe_Str__Node_Label, Safe_Str__Status
+
+
+class Schema__Graph__Node(Type_Safe):                                            # Node summary for graph response
+    label     : Safe_Str__Node_Label
+    title     : Safe_Str__Text
+    node_type : Safe_Str__Node_Type
+    status    : Safe_Str__Status

issues_fs/schemas/graph/Schema__Graph__Response.py

@@ -0,0 +1,21 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Graph__Response - Response types for graph traversal API
+# Used by GET /nodes/api/nodes/{type}/{label}/graph endpoint
+# ═══════════════════════════════════════════════════════════════════════════════
+from typing                                                                         import List
+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 issues_fs.schemas.graph.Safe_Str__Graph_Types import Safe_Str__Node_Label
+from issues_fs.schemas.graph.Schema__Graph__Link   import Schema__Graph__Link
+from issues_fs.schemas.graph.Schema__Graph__Node   import Schema__Graph__Node
+
+
+
+class Schema__Graph__Response(Type_Safe):                                        # Full graph traversal response
+    success   : bool                      = False
+    root      : Safe_Str__Node_Label      = None
+    nodes     : List[Schema__Graph__Node] = None
+    links     : List[Schema__Graph__Link] = None
+    depth     : Safe_UInt                 = 0
+    message   : Safe_Str__Text            = ''

issues_fs/schemas/graph/Schema__Link__Create__Request.py

@@ -0,0 +1,12 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Link__Create__Request - Request body for creating a link between nodes
+# POST /api/nodes/{label}/links
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from osbot_utils.type_safe.Type_Safe                                                         import Type_Safe
+from issues_fs.schemas.graph.Safe_Str__Graph_Types          import Safe_Str__Link_Verb, Safe_Str__Node_Label
+
+
+class Schema__Link__Create__Request(Type_Safe):                                  # Create link request
+    verb         : Safe_Str__Link_Verb                                           # Required: "blocks", "has-task"
+    target_label : Safe_Str__Node_Label                                          # Required: target node label

issues_fs/schemas/graph/Schema__Link__Create__Response.py

@@ -0,0 +1,15 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Link__Create__Response - Response body after creating a link
+# Contains both the forward and inverse links created
+# ═══════════════════════════════════════════════════════════════════════════════
+
+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.graph.Schema__Node__Link             import Schema__Node__Link
+
+
+class Schema__Link__Create__Response(Type_Safe):                                 # Create link response
+    success      : bool                   = False                                # Operation success
+    source_link  : Schema__Node__Link     = None                                 # Link added to source node
+    target_link  : Schema__Node__Link     = None                                 # Inverse link added to target
+    message      : Safe_Str__Text         = ''                                   # Error message if failed

issues_fs/schemas/graph/Schema__Link__Delete__Response.py

@@ -0,0 +1,16 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Link__Delete__Response - Response body after deleting a link
+# DELETE /api/nodes/{label}/links/{target_label}
+# ═══════════════════════════════════════════════════════════════════════════════
+
+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.graph.Safe_Str__Graph_Types          import Safe_Str__Node_Label
+
+
+class Schema__Link__Delete__Response(Type_Safe):                                 # Delete link response
+    success      : bool                   = False                                # Operation success
+    deleted      : bool                   = False                                # Whether link was deleted
+    source_label : Safe_Str__Node_Label   = ''                                   # Source node label
+    target_label : Safe_Str__Node_Label   = ''                                   # Target node label
+    message      : Safe_Str__Text         = ''                                   # Error message if failed

issues_fs/schemas/graph/Schema__Link__List__Response.py

@@ -0,0 +1,15 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Link__List__Response - Response body for listing links from a node
+# GET /api/nodes/{label}/links
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from typing                                                                                  import List
+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.graph.Schema__Node__Link             import Schema__Node__Link
+
+
+class Schema__Link__List__Response(Type_Safe):                                   # List links response
+    success      : bool                      = False                             # Operation success
+    links        : List[Schema__Node__Link]                                      # Links from node
+    message      : Safe_Str__Text            = ''                                # Error message if failed

issues_fs/schemas/graph/Schema__Link__Type.py

@@ -0,0 +1,20 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Link__Type - Definition of a relationship type (blocks, has-task, etc.)
+# Link types define the semantics of relationships between nodes
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from typing                                                                                  import List
+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 issues_fs.schemas.graph.Safe_Str__Graph_Types          import Safe_Str__Link_Verb, Safe_Str__Node_Type
+
+# todo: set link_type_id to Issue__Link_Type__Id  (or Issue__Link__Type__Id)
+class Schema__Link__Type(Type_Safe):                                             # Link type definition
+    link_type_id  : Obj_Id                                                       # Unique identifier
+    verb          : Safe_Str__Link_Verb                                          # "blocks", "has-task"
+    inverse_verb  : Safe_Str__Link_Verb                                          # "blocked-by", "task-of"
+    description   : Safe_Str__Text                                               # What this relationship means
+
+    source_types  : List[Safe_Str__Node_Type]                                    # Valid source node types
+    target_types  : List[Safe_Str__Node_Type]                                    # Valid target node types

issues_fs/schemas/graph/Schema__Node.py

@@ -0,0 +1,43 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Node - Base node structure for graph-based issue tracking
+# All entities (bugs, tasks, features, people) are nodes with typed relationships
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from typing                                                                                         import List, Dict, Any
+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.primitives.domains.identifiers.Node_Id                                   import Node_Id
+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, Safe_Str__Status
+from issues_fs.schemas.graph.Schema__Node__Link                    import Schema__Node__Link
+from issues_fs.schemas.safe_str.Safe_Str__Issue__Node__Description import Safe_Str__Issue__Node__Description
+
+
+# todo: refactor all these classes to use 'Issue' since that is the generic name for this
+#       for example this class should be called 'Schema__Issue__Node'
+class Schema__Node(Type_Safe):                                                   # Base node structure for all entities
+    node_id       : Node_Id                                                       # Random 10-char GUID for machine use
+    node_type     : Safe_Str__Node_Type                                          # Classification: bug, task, feature, person
+    node_index    : Safe_UInt                                                    # Per-type sequential number
+    label         : Safe_Str__Node_Label                                         # Human-readable: "Bug-27", "Task-15"
+
+    # todo: create Safe_Str__Issue__Node__Title  to use here
+    title         : Safe_Str__Text                                               # Display title
+    description   : Safe_Str__Issue__Node__Description                                 # Detailed description
+    status        : Safe_Str__Status                                             # Current status (type-specific)
+
+    created_at    : Timestamp_Now                                                # ISO timestamp created
+    updated_at    : Timestamp_Now                                                # ISO timestamp updated
+    # todo: see what is the best class to use here (Persona_Id , Creator_Id)
+    #             : this should be an id created_by__id and the created_by should be name
+    created_by    : Obj_Id                                                       # Person/agent node_id who created
+
+    # todo: refactor these to use Type_Safe collections, and this should be Safe_Str__Issue__Tag
+    tags          : List[Safe_Str__Text]                                         # Tags/categories (renamed from labels to avoid confusion)
+    # todo: rename to Schema__Issue__Node__Link
+    links         : List[Schema__Node__Link]                                     # Relationships to other nodes
+
+    # todo: this should be an Type_Safe collection and we shouldn't be using raw primitives like str, Any
+    properties    : Dict[str, Any]                                               # Type-specific properties (severity, browser, etc.)

issues_fs/schemas/graph/Schema__Node__Create__Request.py

@@ -0,0 +1,19 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Node__Create__Request - Request body for creating a new node
+# POST /api/nodes
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from typing                                                                                         import List, Dict, Any
+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.graph.Safe_Str__Graph_Types                 import Safe_Str__Node_Type, Safe_Str__Status
+from issues_fs.schemas.safe_str.Safe_Str__Issue__Node__Description import Safe_Str__Issue__Node__Description
+
+
+class Schema__Node__Create__Request(Type_Safe):                                  # Create node request
+    node_type   : Safe_Str__Node_Type                                            # Required: "bug", "task", etc.
+    title       : Safe_Str__Text                                                 # Required: display title
+    description : Safe_Str__Issue__Node__Description                             # Optional description
+    status      : Safe_Str__Status      = None                                   # Optional: defaults to type's default
+    tags        : List[Safe_Str__Text]                                           # Optional tags
+    properties  : Dict[str, Any]                                                 # Type-specific properties

issues_fs/schemas/graph/Schema__Node__Create__Response.py

@@ -0,0 +1,14 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Node__Create__Response - Response body after creating a node
+# POST /api/nodes
+# ═══════════════════════════════════════════════════════════════════════════════
+
+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.graph.Schema__Node                   import Schema__Node
+
+
+class Schema__Node__Create__Response(Type_Safe):                                 # Create node response
+    success     : bool                  = False                                  # Operation success
+    node        : Schema__Node          = None                                   # Created node data
+    message     : Safe_Str__Text        = ''                                     # Error message if failed

issues_fs/schemas/graph/Schema__Node__Delete__Response.py

@@ -0,0 +1,15 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Node__Delete__Response - Response body after deleting a node
+# DELETE /api/nodes/{label}
+# ═══════════════════════════════════════════════════════════════════════════════
+
+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.graph.Safe_Str__Graph_Types          import Safe_Str__Node_Label
+
+
+class Schema__Node__Delete__Response(Type_Safe):                                 # Delete node response
+    success     : bool                  = False                                  # Operation success
+    deleted     : bool                  = False                                  # Whether node was deleted
+    label       : Safe_Str__Node_Label  = ''                                     # Deleted node label
+    message     : Safe_Str__Text        = ''                                     # Error message if failed

issues_fs/schemas/graph/Schema__Node__Link.py

@@ -0,0 +1,17 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Node__Link - Relationship edge between nodes
+# Links are bidirectional and denormalized (stored on both ends)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+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__Link_Verb, Safe_Str__Node_Label
+
+
+class Schema__Node__Link(Type_Safe):                                             # Relationship to another node
+    link_type_id  : Obj_Id                                                       # Reference to link type definition
+    verb          : Safe_Str__Link_Verb                                          # "blocks", "has-task", "assigned-to"
+    target_id     : Obj_Id                                                       # Target node's node_id
+    target_label  : Safe_Str__Node_Label                                         # Denormalized: "Task-15" for display
+    created_at    : Timestamp_Now                                                # When link was created

issues_fs/schemas/graph/Schema__Node__List__Response.py

@@ -0,0 +1,16 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Node__List__Response - Response body for listing nodes
+# GET /api/nodes or GET /api/nodes/type/{node_type}
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from typing                                                                                  import List
+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.graph.Schema__Node__Summary          import Schema__Node__Summary
+
+
+class Schema__Node__List__Response(Type_Safe):                                   # List nodes response
+    success     : bool                        = False                            # Operation success
+    nodes       : List[Schema__Node__Summary]                                    # Node summaries
+    total       : int                         = 0                                # Total count
+    message     : Safe_Str__Text              = ''                               # Error message if failed

issues_fs/schemas/graph/Schema__Node__Summary.py

@@ -0,0 +1,15 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Node__Summary - Lightweight node summary for list responses
+# Contains only essential fields for display in lists
+# ═══════════════════════════════════════════════════════════════════════════════
+
+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.graph.Safe_Str__Graph_Types         import Safe_Str__Node_Label, Safe_Str__Node_Type, Safe_Str__Status
+
+
+class Schema__Node__Summary(Type_Safe):                                          # Node summary for listings
+    label       : Safe_Str__Node_Label                                           # "Bug-27"
+    node_type   : Safe_Str__Node_Type                                            # "bug"
+    title       : Safe_Str__Text                                                 # Display title
+    status      : Safe_Str__Status                                               # Current status

issues_fs/schemas/graph/Schema__Node__Type.py

@@ -0,0 +1,28 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Node__Type - Definition of a node type (bug, task, feature, etc.)
+# Each type has its own statuses, properties, and display configuration
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from typing                                                                                  import List
+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 issues_fs.schemas.graph.Safe_Str__Graph_Types          import Safe_Str__Node_Type, Safe_Str__Node_Type_Display, Safe_Str__Status
+from issues_fs.schemas.graph.Schema__Property__Definition   import Schema__Property__Definition
+from issues_fs.schemas.safe_str.Safe_Str__Hex_Color         import Safe_Str__Hex_Color
+
+# todo: refactor to Schema__Issue__Node__Type
+#       (do the same *__Issue__* refactoring where applicable
+class Schema__Node__Type(Type_Safe):                                             # Node type definition
+    #todo: refactor to Issue__Node__Type_Id
+    type_id        : Obj_Id                                                      # Unique identifier for this type
+    name           : Safe_Str__Node_Type                                         # "bug", "task", "feature"
+    display_name   : Safe_Str__Node_Type_Display                                 # "Bug", "Task", "Feature"
+    description    : Safe_Str__Text                                              # What this type represents
+    icon           : Safe_Str__Text                                              # Icon identifier (optional)
+    color          : Safe_Str__Hex_Color                                         # Display color like #ef4444
+
+    statuses       : List[Safe_Str__Status]                                      # Valid statuses for this type
+    default_status : Safe_Str__Status                                            # Initial status for new nodes
+
+    properties     : List[Schema__Property__Definition]                          # Type-specific field definitions

issues_fs/schemas/graph/Schema__Node__Update__Request.py

@@ -0,0 +1,18 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Node__Update__Request - Request body for updating an existing node
+# PATCH /api/nodes/{label} - All fields optional (partial update)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from typing                                                                                  import List, Dict, Any
+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.graph.Safe_Str__Graph_Types          import Safe_Str__Status
+from issues_fs.schemas.safe_str.Safe_Str__Issue__Node__Description import Safe_Str__Issue__Node__Description
+
+
+class Schema__Node__Update__Request(Type_Safe):                                  # Update node request (partial)
+    title       : Safe_Str__Text                     = None                      # New title
+    description : Safe_Str__Issue__Node__Description = None                      # New description
+    status      : Safe_Str__Status                   = None                      # New status
+    tags        : List[Safe_Str__Text]               = None                      # New tags (replaces existing)
+    properties  : Dict[str, Any]                     = None                      # New properties (merged)

issues_fs/schemas/graph/Schema__Node__Update__Response.py

@@ -0,0 +1,14 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Node__Update__Response - Response body after updating a node
+# PATCH /api/nodes/{label}
+# ═══════════════════════════════════════════════════════════════════════════════
+
+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.graph.Schema__Node                   import Schema__Node
+
+
+class Schema__Node__Update__Response(Type_Safe):                                 # Update node response
+    success     : bool                  = False                                  # Operation success
+    node        : Schema__Node          = None                                   # Updated node data
+    message     : Safe_Str__Text        = ''                                     # Error message if failed

issues_fs/schemas/graph/Schema__Property__Definition.py

@@ -0,0 +1,27 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Property__Definition - Definition of a type-specific property field
+# Properties allow each node type to have its own custom fields
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from typing                                                                      import List
+from enum                                                                        import Enum
+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
+
+
+class Enum__Property__Type(str, Enum):                                           # Property value types
+    STRING   = "string"                                                          # Free text
+    NUMBER   = "number"                                                          # Numeric value
+    BOOLEAN  = "boolean"                                                         # True/false
+    ENUM     = "enum"                                                            # Predefined options
+    DATE     = "date"                                                            # ISO date string
+    DATETIME = "datetime"                                                        # ISO datetime string
+
+
+class Schema__Property__Definition(Type_Safe):                                   # Custom property definition
+    name         : Safe_Str__Text                                                # Property name like "severity"
+    prop_type    : Enum__Property__Type = Enum__Property__Type.STRING            # Value type
+    description  : Safe_Str__Text                                                # What this property represents
+    required     : bool                 = False                                  # Whether property is required
+    options      : List[Safe_Str__Text]                                          # For ENUM type: valid options
+    default      : Safe_Str__Text       = None                                   # Default value (optional)

issues_fs/schemas/graph/Schema__Type__Index.py

@@ -0,0 +1,16 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Type__Index - Per-type index tracking for node counts and next ID
+# Stored at .issues/data/{node_type}/_index.json
+# ═══════════════════════════════════════════════════════════════════════════════
+
+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.safe_int.Timestamp_Now            import Timestamp_Now
+from issues_fs.schemas.graph.Safe_Str__Graph_Types         import Safe_Str__Node_Type
+
+
+class Schema__Type__Index(Type_Safe):                                            # Per-type index file
+    node_type     : Safe_Str__Node_Type                                          # "bug", "task", etc.
+    next_index    : Safe_UInt            = Safe_UInt(1)                          # Next available index
+    count         : Safe_UInt            = Safe_UInt(0)                          # Total nodes of this type
+    last_updated  : Timestamp_Now        = None                                  # ISO timestamp

issues_fs/schemas/graph/Schema__Type__Summary.py

@@ -0,0 +1,13 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Type__Summary - Summary of node count for a single type
+# Used within Schema__Global__Index
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from osbot_utils.type_safe.Type_Safe                                                         import Type_Safe
+from osbot_utils.type_safe.primitives.core.Safe_UInt                                         import Safe_UInt
+from issues_fs.schemas.graph.Safe_Str__Graph_Types          import Safe_Str__Node_Type
+
+
+class Schema__Type__Summary(Type_Safe):                                          # Summary for a node type
+    node_type     : Safe_Str__Node_Type                                          # Type name
+    count         : Safe_UInt            = Safe_UInt(0)                          # Node count

issues_fs/schemas/identifiers/Comment_Id.py

@@ -0,0 +1,5 @@
+from issues_fs.schemas.identifiers.Issue_Id import Issue_Id
+
+
+class Comment_Id(Issue_Id):
+    pass

issues_fs/schemas/identifiers/Issue_Id.py

@@ -0,0 +1,13 @@
+from osbot_utils.type_safe.primitives.domains.identifiers.Obj_Id import Obj_Id
+
+# we need to refactor the code to use this
+class Issue_Id(Obj_Id):                                 # Obj_Id that allows empty values (needed for serialisation)
+    def __new__(cls, value=None):
+        if value is None or value == '':
+            return str.__new__(cls, '')
+        else:
+            return super().__new__(cls, value)
+
+    @classmethod
+    def new(cls):                                       # helper method for the easy creation of non-empty Issue_ids
+        return cls(Obj_Id())

issues_fs/schemas/issues/Schema__Comment.py

@@ -0,0 +1,61 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Schema__Comment - Data types for comments on nodes
+# ═══════════════════════════════════════════════════════════════════════════════
+
+from typing                                                                      import List, Optional
+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 osbot_utils.type_safe.primitives.domains.common.safe_str.Safe_Str__Text     import Safe_Str__Text
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Comment Schema
+# ═══════════════════════════════════════════════════════════════════════════════
+
+# todo: this should be Schema__Issue__Comment
+#       refactor each of these files into a separate schema file
+#       change id to comment_id
+class Schema__Comment(Type_Safe):                                                # Single comment on a node
+    id         : Obj_Id                                                          # Unique comment ID
+    author     : Safe_Str__Text                                                  # Who wrote it: 'human', 'claude-code', etc.
+    text       : Safe_Str__Text                                                  # Comment content (supports markdown)
+    created_at : Timestamp_Now                                                   # When created
+    updated_at : Timestamp_Now                                                   # When last edited
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Request Schemas
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class Schema__Comment__Create__Request(Type_Safe):                               # Create comment request
+    author     : Safe_Str__Text                                                  # Who is writing
+    text       : Safe_Str__Text                                                  # Comment content
+
+
+class Schema__Comment__Update__Request(Type_Safe):                               # Update comment request
+    text       : Safe_Str__Text                                                  # New comment content
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Response Schemas
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class Schema__Comment__Response(Type_Safe):                                      # Single comment response
+    success    : bool              = False
+    comment    : Schema__Comment   = None
+    message    : str               = ''
+
+
+class Schema__Comment__List__Response(Type_Safe):                                # List comments response
+    success    : bool                   = False
+    comments   : List[Schema__Comment]  = None
+    total      : int                    = 0
+    message    : str                    = ''
+
+
+class Schema__Comment__Delete__Response(Type_Safe):                              # Delete comment response
+    success    : bool   = False
+    deleted    : bool   = False
+    comment_id : str    = ''
+    message    : str    = ''