mcp-ticketer 0.12.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

mcp_ticketer/core/mappers.py

@@ -98,13 +98,13 @@ class StateMapper(BaseMapper):
         self._mapping: BiDirectionalDict | None = None
 
     @lru_cache(maxsize=1)
-    def get_mapping(self) -> BiDirectionalDict:
+    def get_mapping(self) -> BiDirectionalDict[TicketState, str]:
         """Get cached bidirectional state mapping."""
         if self._mapping is not None:
             return self._mapping
 
         # Default mappings by adapter type
-        default_mappings = {
+        default_mappings: dict[str, dict[TicketState, str]] = {
             "github": {
                 TicketState.OPEN: "open",
                 TicketState.IN_PROGRESS: "open",  # Uses labels
@@ -147,13 +147,16 @@ class StateMapper(BaseMapper):
             },
         }
 
-        mapping = default_mappings.get(self.adapter_type, {})
+        mapping: dict[TicketState, str] = default_mappings.get(self.adapter_type, {})
 
-        # Apply custom mappings
+        # Apply custom mappings (cast to proper type)
         if self.custom_mappings:
-            mapping.update(self.custom_mappings)
+            # custom_mappings might have str keys, need to convert to TicketState
+            for key, value in self.custom_mappings.items():
+                if isinstance(key, TicketState):
+                    mapping[key] = value
 
-        self._mapping = BiDirectionalDict(mapping)
+        self._mapping = BiDirectionalDict[TicketState, str](mapping)
         return self._mapping
 
     def to_system_state(self, adapter_state: str) -> TicketState:
@@ -168,7 +171,9 @@ class StateMapper(BaseMapper):
         """
         cache_key = f"to_system_{adapter_state}"
         if cache_key in self._cache:
-            return self._cache[cache_key]
+            cached = self._cache[cache_key]
+            if isinstance(cached, TicketState):
+                return cached
 
         mapping = self.get_mapping()
         result = mapping.get_reverse(adapter_state)
@@ -205,7 +210,9 @@ class StateMapper(BaseMapper):
         """
         cache_key = f"from_system_{system_state.value}"
         if cache_key in self._cache:
-            return self._cache[cache_key]
+            cached = self._cache[cache_key]
+            if isinstance(cached, str):
+                return cached
 
         mapping = self.get_mapping()
         result = mapping.get_forward(system_state)
@@ -273,13 +280,13 @@ class PriorityMapper(BaseMapper):
         self._mapping: BiDirectionalDict | None = None
 
     @lru_cache(maxsize=1)
-    def get_mapping(self) -> BiDirectionalDict:
+    def get_mapping(self) -> BiDirectionalDict[Priority, Any]:
         """Get cached bidirectional priority mapping."""
         if self._mapping is not None:
             return self._mapping
 
         # Default mappings by adapter type
-        default_mappings = {
+        default_mappings: dict[str, dict[Priority, Any]] = {
             "github": {
                 Priority.CRITICAL: "P0",
                 Priority.HIGH: "P1",
@@ -306,13 +313,16 @@ class PriorityMapper(BaseMapper):
             },
         }
 
-        mapping = default_mappings.get(self.adapter_type, {})
+        mapping: dict[Priority, Any] = default_mappings.get(self.adapter_type, {})
 
-        # Apply custom mappings
+        # Apply custom mappings (cast to proper type)
         if self.custom_mappings:
-            mapping.update(self.custom_mappings)
+            # custom_mappings might have str keys, need to convert to Priority
+            for key, value in self.custom_mappings.items():
+                if isinstance(key, Priority):
+                    mapping[key] = value
 
-        self._mapping = BiDirectionalDict(mapping)
+        self._mapping = BiDirectionalDict[Priority, Any](mapping)
         return self._mapping
 
     def to_system_priority(self, adapter_priority: Any) -> Priority:
@@ -327,7 +337,9 @@ class PriorityMapper(BaseMapper):
         """
         cache_key = f"to_system_{adapter_priority}"
         if cache_key in self._cache:
-            return self._cache[cache_key]
+            cached = self._cache[cache_key]
+            if isinstance(cached, Priority):
+                return cached
 
         mapping = self.get_mapping()
         result = mapping.get_reverse(adapter_priority)
@@ -524,10 +536,10 @@ class MapperRegistry:
     @classmethod
     def clear_cache(cls) -> None:
         """Clear all mapper caches."""
-        for mapper in cls._state_mappers.values():
-            mapper.clear_cache()
-        for mapper in cls._priority_mappers.values():
-            mapper.clear_cache()
+        for state_mapper in cls._state_mappers.values():
+            state_mapper.clear_cache()
+        for priority_mapper in cls._priority_mappers.values():
+            priority_mapper.clear_cache()
 
     @classmethod
     def reset(cls) -> None:

mcp_ticketer/core/models.py

@@ -160,6 +160,37 @@ class TicketState(str, Enum):
         """
         return target.value in self.valid_transitions().get(self, [])
 
+    def completion_level(self) -> int:
+        """Get numeric completion level for state ordering.
+
+        Higher numbers indicate more complete states. Used for parent/child
+        state constraints where parents must be at least as complete as
+        their most complete child.
+
+        Returns:
+            Completion level (0-7)
+
+        Example:
+            >>> TicketState.OPEN.completion_level()
+            0
+            >>> TicketState.DONE.completion_level()
+            6
+            >>> TicketState.DONE.completion_level() > TicketState.IN_PROGRESS.completion_level()
+            True
+
+        """
+        levels = {
+            TicketState.OPEN: 0,  # Not started
+            TicketState.BLOCKED: 1,  # Blocked
+            TicketState.WAITING: 2,  # Waiting
+            TicketState.IN_PROGRESS: 3,  # In progress
+            TicketState.READY: 4,  # Ready for review
+            TicketState.TESTED: 5,  # Tested
+            TicketState.DONE: 6,  # Done
+            TicketState.CLOSED: 7,  # Closed (terminal)
+        }
+        return levels.get(self, 0)
+
 
 class BaseTicket(BaseModel):
     """Base model for all ticket types with universal field mapping.
@@ -385,6 +416,109 @@ class Attachment(BaseModel):
         return f"Attachment({self.filename}{size_str})"
 
 
+class ProjectUpdateHealth(str, Enum):
+    """Project health status indicator for status updates.
+
+    Represents the health/status of a project at the time of an update.
+    These states map to different platform-specific health indicators:
+
+    Platform Mappings:
+    - Linear: on_track, at_risk, off_track (1:1 mapping)
+    - GitHub V2: Uses ProjectV2StatusOptionConfiguration
+      - complete: Project is finished
+      - inactive: Project is not actively being worked on
+    - Asana: On Track, At Risk, Off Track (1:1 mapping)
+    - JIRA: Not directly supported (workaround via status comments)
+
+    Attributes:
+        ON_TRACK: Project is progressing as planned
+        AT_RISK: Project has some issues but recoverable
+        OFF_TRACK: Project is significantly behind or blocked
+        COMPLETE: Project is finished (GitHub-specific)
+        INACTIVE: Project is not actively being worked on (GitHub-specific)
+
+    Note:
+        Related to ticket 1M-238: Add project updates support with flexible
+        project identification.
+
+    """
+
+    ON_TRACK = "on_track"  # Linear, Asana
+    AT_RISK = "at_risk"  # Linear, Asana
+    OFF_TRACK = "off_track"  # Linear, Asana
+    COMPLETE = "complete"  # GitHub only
+    INACTIVE = "inactive"  # GitHub only
+
+
+class ProjectUpdate(BaseModel):
+    """Represents a project status update across different platforms.
+
+    ProjectUpdate provides a unified interface for creating and retrieving
+    project status updates with health indicators, supporting Linear, GitHub V2,
+    Asana, and JIRA (via workaround).
+
+    Platform Mappings:
+    - Linear: ProjectUpdate entity with health, diff_markdown, staleness
+    - GitHub V2: ProjectV2StatusUpdate with status options
+    - Asana: Project Status Updates with color-coded health
+    - JIRA: Comments with custom formatting (workaround)
+
+    The model includes platform-specific optional fields to support features
+    like Linear's auto-generated diffs and staleness indicators.
+
+    Attributes:
+        id: Unique identifier for the update
+        project_id: ID of the project this update belongs to
+        project_name: Optional human-readable project name
+        body: Markdown-formatted update content (required)
+        health: Optional health status indicator
+        created_at: Timestamp when update was created
+        updated_at: Timestamp when update was last modified
+        author_id: Optional ID of the user who created the update
+        author_name: Optional human-readable author name
+        url: Optional direct URL to the update
+        diff_markdown: Linear-specific auto-generated diff of project changes
+        is_stale: Linear-specific indicator if update is outdated
+
+    Example:
+        >>> update = ProjectUpdate(
+        ...     project_id="PROJ-123",
+        ...     body="Sprint completed with 15/20 stories done",
+        ...     health=ProjectUpdateHealth.AT_RISK,
+        ...     created_at=datetime.now()
+        ... )
+        >>> print(update.model_dump_json())
+
+    Note:
+        Related to ticket 1M-238: Add project updates support with flexible
+        project identification.
+
+    """
+
+    model_config = ConfigDict(use_enum_values=True)
+
+    id: str = Field(..., description="Unique update identifier")
+    project_id: str = Field(..., description="Parent project identifier")
+    project_name: str | None = Field(None, description="Human-readable project name")
+    body: str = Field(..., min_length=1, description="Markdown update content")
+    health: ProjectUpdateHealth | None = Field(
+        None, description="Project health status"
+    )
+    created_at: datetime = Field(..., description="Creation timestamp")
+    updated_at: datetime | None = Field(None, description="Last update timestamp")
+    author_id: str | None = Field(None, description="Update author identifier")
+    author_name: str | None = Field(None, description="Update author name")
+    url: str | None = Field(None, description="Direct URL to update")
+
+    # Platform-specific fields
+    diff_markdown: str | None = Field(
+        None, description="Linear: Auto-generated diff of project changes"
+    )
+    is_stale: bool | None = Field(
+        None, description="Linear: Indicator if update is outdated"
+    )
+
+
 class SearchQuery(BaseModel):
     """Search query parameters."""
 
@@ -393,5 +527,6 @@ class SearchQuery(BaseModel):
     priority: Priority | None = Field(None, description="Filter by priority")
     tags: list[str] | None = Field(None, description="Filter by tags")
     assignee: str | None = Field(None, description="Filter by assignee")
+    project: str | None = Field(None, description="Filter by project/epic ID or name")
     limit: int = Field(10, gt=0, le=100, description="Maximum results")
     offset: int = Field(0, ge=0, description="Result offset for pagination")

mcp_ticketer/core/onepassword_secrets.py

@@ -334,7 +334,7 @@ def check_op_cli_status() -> dict[str, Any]:
     """
     loader = OnePasswordSecretsLoader()
 
-    status = {
+    status: dict[str, Any] = {
         "installed": loader.is_op_available(),
         "authenticated": False,
         "version": None,