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

mcp_ticketer/__init__.py

@@ -1,16 +1,16 @@
 """MCP Ticketer - Universal ticket management interface."""
 
 from .__version__ import (
-                          __author__,
-                          __author_email__,
-                          __copyright__,
-                          __description__,
-                          __license__,
-                          __title__,
-                          __version__,
-                          __version_info__,
-                          get_user_agent,
-                          get_version,
+    __author__,
+    __author_email__,
+    __copyright__,
+    __description__,
+    __license__,
+    __title__,
+    __version__,
+    __version_info__,
+    get_user_agent,
+    get_version,
 )
 
 __all__ = [

mcp_ticketer/__version__.py

@@ -1,6 +1,6 @@
 """Version information for mcp-ticketer package."""
 
-__version__ = "0.4.11"
+__version__ = "2.0.1"
 __version_info__ = tuple(int(part) for part in __version__.split("."))
 
 # Package metadata
@@ -27,7 +27,7 @@ __features__ = {
 }
 
 
-def get_version():
+def get_version() -> str:
     """Return the full version string with build metadata if available."""
     version = __version__
     if __build__:
@@ -37,6 +37,6 @@ def get_version():
     return version
 
 
-def get_user_agent():
+def get_user_agent() -> str:
     """Return a user agent string for API requests."""
     return f"{__title__}/{__version__}"

mcp_ticketer/adapters/__init__.py

@@ -1,6 +1,7 @@
 """Adapter implementations for various ticket systems."""
 
 from .aitrackdown import AITrackdownAdapter
+from .asana import AsanaAdapter
 from .github import GitHubAdapter
 from .hybrid import HybridAdapter
 from .jira import JiraAdapter
@@ -8,6 +9,7 @@ from .linear import LinearAdapter
 
 __all__ = [
     "AITrackdownAdapter",
+    "AsanaAdapter",
     "LinearAdapter",
     "JiraAdapter",
     "GitHubAdapter",

mcp_ticketer/adapters/aitrackdown.py

@@ -23,14 +23,14 @@ logger = logging.getLogger(__name__)
 
 # Import ai-trackdown-pytools when available
 try:
-    from ai_trackdown_pytools import AITrackdown
-    from ai_trackdown_pytools import Ticket as AITicket
+    from ai_trackdown_pytools import AITrackdown  # type: ignore[attr-defined]
+    from ai_trackdown_pytools import Ticket as AITicket  # type: ignore[attr-defined]
 
     HAS_AITRACKDOWN = True
 except ImportError:
     HAS_AITRACKDOWN = False
-    AITrackdown = None
-    AITicket = None
+    AITrackdown = None  # type: ignore[assignment]
+    AITicket = None  # type: ignore[assignment]
 
 
 class AITrackdownAdapter(BaseAdapter[Task]):
@@ -40,6 +40,7 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         """Initialize AI-Trackdown adapter.
 
         Args:
+        ----
             config: Configuration with 'base_path' for tickets directory
 
         """
@@ -64,6 +65,7 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         AITrackdown is file-based and doesn't require credentials.
 
         Returns:
+        -------
             (is_valid, error_message) - Always returns (True, "") for AITrackdown
 
         """
@@ -128,6 +130,8 @@ class AITrackdownAdapter(BaseAdapter[Task]):
             parent_issue=ai_ticket.get("parent_issue"),
             parent_epic=ai_ticket.get("parent_epic"),
             assignee=ai_ticket.get("assignee"),
+            estimated_hours=ai_ticket.get("estimated_hours"),
+            actual_hours=ai_ticket.get("actual_hours"),
             created_at=(
                 datetime.fromisoformat(ai_ticket["created_at"])
                 if "created_at" in ai_ticket
@@ -180,13 +184,15 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         """Convert universal Task to AI-Trackdown ticket."""
         # Handle enum values that may be stored as strings due to use_enum_values=True
         # Note: task.state is always a string due to ConfigDict(use_enum_values=True)
-        state_value = task.state
+        state_value: str
         if isinstance(task.state, TicketState):
             state_value = self._get_state_mapping()[task.state]
         elif isinstance(task.state, str):
             # Already a string - keep as-is (don't convert to kebab-case)
             # The state is already in snake_case format from the enum value
             state_value = task.state
+        else:
+            state_value = str(task.state)
 
         return {
             "id": task.id,
@@ -208,13 +214,15 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         """Convert universal Epic to AI-Trackdown ticket."""
         # Handle enum values that may be stored as strings due to use_enum_values=True
         # Note: epic.state is always a string due to ConfigDict(use_enum_values=True)
-        state_value = epic.state
+        state_value: str
         if isinstance(epic.state, TicketState):
             state_value = self._get_state_mapping()[epic.state]
         elif isinstance(epic.state, str):
             # Already a string - keep as-is (don't convert to kebab-case)
             # The state is already in snake_case format from the enum value
             state_value = epic.state
+        else:
+            state_value = str(epic.state)
 
         return {
             "id": epic.id,
@@ -280,15 +288,19 @@ class AITrackdownAdapter(BaseAdapter[Task]):
 
         return ticket
 
-    async def create_epic(self, title: str, description: str = None, **kwargs) -> Epic:
+    async def create_epic(
+        self, title: str, description: str = None, **kwargs: Any
+    ) -> Epic:
         """Create a new epic.
 
         Args:
+        ----
             title: Epic title
             description: Epic description
             **kwargs: Additional epic properties
 
         Returns:
+        -------
             Created Epic instance
 
         """
@@ -296,17 +308,23 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         return await self.create(epic)
 
     async def create_issue(
-        self, title: str, parent_epic: str = None, description: str = None, **kwargs
+        self,
+        title: str,
+        parent_epic: str = None,
+        description: str = None,
+        **kwargs: Any,
     ) -> Task:
         """Create a new issue.
 
         Args:
+        ----
             title: Issue title
             parent_epic: Parent epic ID
             description: Issue description
             **kwargs: Additional issue properties
 
         Returns:
+        -------
             Created Task instance (representing an issue)
 
         """
@@ -316,17 +334,19 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         return await self.create(task)
 
     async def create_task(
-        self, title: str, parent_id: str, description: str = None, **kwargs
+        self, title: str, parent_id: str, description: str = None, **kwargs: Any
     ) -> Task:
         """Create a new task under an issue.
 
         Args:
+        ----
             title: Task title
             parent_id: Parent issue ID
             description: Task description
             **kwargs: Additional task properties
 
         Returns:
+        -------
             Created Task instance
 
         """
@@ -356,13 +376,16 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         """Update a task or epic.
 
         Args:
+        ----
             ticket_id: ID of ticket to update
             updates: Dictionary of updates or Task object with new values
 
         Returns:
+        -------
             Updated Task or Epic, or None if ticket not found
 
         Raises:
+        ------
             AttributeError: If update fails due to invalid fields
 
         """
@@ -549,9 +572,11 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         """Get epic by ID.
 
         Args:
+        ----
             epic_id: Epic ID to retrieve
 
         Returns:
+        -------
             Epic if found, None otherwise
 
         """
@@ -574,10 +599,12 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         """List all epics.
 
         Args:
+        ----
             limit: Maximum number of epics to return
             offset: Number of epics to skip
 
         Returns:
+        -------
             List of epics
 
         """
@@ -592,9 +619,11 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         """List all issues belonging to an epic.
 
         Args:
+        ----
             epic_id: Epic ID to get issues for
 
         Returns:
+        -------
             List of issues (tasks with parent_epic set)
 
         """
@@ -609,9 +638,11 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         """List all tasks belonging to an issue.
 
         Args:
+        ----
             issue_id: Issue ID (parent task) to get child tasks for
 
         Returns:
+        -------
             List of tasks
 
         """
@@ -627,9 +658,11 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         """Sanitize filename to prevent security issues.
 
         Args:
+        ----
             filename: Original filename
 
         Returns:
+        -------
             Sanitized filename safe for filesystem
 
         """
@@ -649,9 +682,11 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         """Guess MIME type from file extension.
 
         Args:
+        ----
             file_path: Path to file
 
         Returns:
+        -------
             MIME type string
 
         """
@@ -664,9 +699,11 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         """Calculate SHA256 checksum of file.
 
         Args:
+        ----
             file_path: Path to file
 
         Returns:
+        -------
             Hexadecimal checksum string
 
         """
@@ -689,14 +726,17 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         """Attach a file to a ticket (local filesystem storage).
 
         Args:
+        ----
             ticket_id: Ticket identifier
             file_path: Local file path to attach
             description: Optional attachment description
 
         Returns:
+        -------
             Attachment metadata
 
         Raises:
+        ------
             ValueError: If ticket doesn't exist
             FileNotFoundError: If file doesn't exist
 
@@ -761,9 +801,11 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         """Get all attachments for a ticket with path traversal protection.
 
         Args:
+        ----
             ticket_id: Ticket identifier
 
         Returns:
+        -------
             List of attachments (empty if none)
 
         """
@@ -814,10 +856,12 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         """Delete an attachment and its metadata with path traversal protection.
 
         Args:
+        ----
             ticket_id: Ticket identifier
             attachment_id: Attachment identifier
 
         Returns:
+        -------
             True if deleted, False if not found
 
         """
@@ -855,6 +899,347 @@ class AITrackdownAdapter(BaseAdapter[Task]):
 
         return deleted
 
+    async def update_epic(self, epic_id: str, updates: dict[str, Any]) -> Epic | None:
+        """Update an epic (project) in AITrackdown.
+
+        Args:
+        ----
+            epic_id: Epic identifier (filename without .json)
+            updates: Dictionary of fields to update. Supported fields:
+                - title: Epic title
+                - description: Epic description
+                - state: TicketState value
+                - priority: Priority value
+                - tags: List of tags
+                - target_date: Target completion date
+                - metadata: User metadata dictionary
+
+        Returns:
+        -------
+            Updated Epic object or None if epic not found
+
+        Raises:
+        ------
+            ValueError: If epic_id is invalid or epic not found
+
+        Note:
+        ----
+            AITrackdown stores epics as JSON files in {storage_path}/tickets/
+            Updates are applied as partial updates (only specified fields changed)
+
+        """
+        # Validate epic_id
+        if not epic_id:
+            raise ValueError("epic_id is required")
+
+        # Read existing epic
+        existing = await self.read(epic_id)
+        if not existing:
+            logger.warning("Epic %s not found for update", epic_id)
+            return None
+
+        # Ensure it's an epic, not a task
+        if not isinstance(existing, Epic):
+            logger.warning("Ticket %s is not an epic", epic_id)
+            return None
+
+        # Apply updates to the existing epic
+        for key, value in updates.items():
+            if hasattr(existing, key) and value is not None:
+                setattr(existing, key, value)
+
+        # Update timestamp
+        existing.updated_at = datetime.now()
+
+        # Write back to file
+        ai_ticket = self._epic_to_ai_ticket(existing)
+        self._write_ticket_file(epic_id, ai_ticket)
+
+        logger.info("Updated epic %s with fields: %s", epic_id, list(updates.keys()))
+        return existing
+
+    async def list_labels(self, limit: int = 100) -> builtins.list[dict[str, Any]]:
+        """List all tags (labels) used across tickets.
+
+        Args:
+        ----
+            limit: Maximum number of labels to return (default: 100)
+
+        Returns:
+        -------
+            List of label dictionaries sorted by usage count (descending).
+            Each dictionary contains:
+                - id: Tag name (same as name in AITrackdown)
+                - name: Tag name
+                - count: Number of tickets using this tag
+
+        Note:
+        ----
+            AITrackdown uses 'tags' terminology. This method scans
+            all task and epic files to extract unique tags.
+
+        """
+        # Initialize tag counter
+        tag_counts: dict[str, int] = {}
+
+        # Scan all ticket JSON files
+        if self.tickets_dir.exists():
+            for ticket_file in self.tickets_dir.glob("*.json"):
+                try:
+                    with open(ticket_file) as f:
+                        ticket_data = json.load(f)
+                        tags = ticket_data.get("tags", [])
+                        for tag in tags:
+                            tag_counts[tag] = tag_counts.get(tag, 0) + 1
+                except (json.JSONDecodeError, OSError) as e:
+                    logger.warning("Failed to read ticket file %s: %s", ticket_file, e)
+                    continue
+
+        # Sort by usage count (descending)
+        sorted_tags = sorted(tag_counts.items(), key=lambda x: x[1], reverse=True)
+
+        # Return top N tags with standardized format
+        return [
+            {"id": tag, "name": tag, "count": count}
+            for tag, count in sorted_tags[:limit]
+        ]
+
+    async def create_issue_label(
+        self, name: str, color: str | None = None
+    ) -> dict[str, Any]:
+        """Create/register a label (tag) in AITrackdown.
+
+        Args:
+        ----
+            name: Label name (alphanumeric, hyphens, underscores allowed)
+            color: Optional color (not used in file-based storage)
+
+        Returns:
+        -------
+            Label dictionary with:
+                - id: Label name
+                - name: Label name
+                - color: Color value (if provided)
+                - created: True (always, as tags are created on use)
+
+        Raises:
+        ------
+            ValueError: If label name is invalid
+
+        Note:
+        ----
+            AITrackdown creates tags implicitly when used on tickets.
+            This method validates the tag name and returns success.
+            Tags are stored as arrays in ticket JSON files.
+
+        """
+        # Validate tag name
+        if not name:
+            raise ValueError("Label name cannot be empty")
+
+        # Check for valid characters (alphanumeric, hyphens, underscores, spaces)
+        import re
+
+        if not re.match(r"^[a-zA-Z0-9_\- ]+$", name):
+            raise ValueError(
+                "Label name must contain only alphanumeric characters, hyphens, underscores, or spaces"
+            )
+
+        # Return success response
+        logger.info("Label '%s' registered (created implicitly on use)", name)
+        return {
+            "id": name,
+            "name": name,
+            "color": color,
+            "created": True,
+        }
+
+    async def list_project_labels(
+        self, epic_id: str, limit: int = 100
+    ) -> builtins.list[dict[str, Any]]:
+        """List labels (tags) used in a specific epic and its tasks.
+
+        Args:
+        ----
+            epic_id: Epic identifier
+            limit: Maximum number of labels to return (default: 100)
+
+        Returns:
+        -------
+            List of label dictionaries used in the epic, sorted by usage count.
+            Each dictionary contains:
+                - id: Tag name
+                - name: Tag name
+                - count: Number of tickets using this tag within the epic
+
+        Raises:
+        ------
+            ValueError: If epic not found
+
+        Note:
+        ----
+            Scans the epic and all tasks with parent_epic == epic_id.
+
+        """
+        # Validate epic exists
+        epic = await self.get_epic(epic_id)
+        if not epic:
+            raise ValueError(f"Epic {epic_id} not found")
+
+        # Initialize tag counter
+        tag_counts: dict[str, int] = {}
+
+        # Add tags from the epic itself
+        if epic.tags:
+            for tag in epic.tags:
+                tag_counts[tag] = tag_counts.get(tag, 0) + 1
+
+        # Find all tasks with parent_epic == epic_id
+        all_tasks = await self.list_issues_by_epic(epic_id)
+        for task in all_tasks:
+            if task.tags:
+                for tag in task.tags:
+                    tag_counts[tag] = tag_counts.get(tag, 0) + 1
+
+        # Sort by usage count (descending)
+        sorted_tags = sorted(tag_counts.items(), key=lambda x: x[1], reverse=True)
+
+        # Return top N tags
+        return [
+            {"id": tag, "name": tag, "count": count}
+            for tag, count in sorted_tags[:limit]
+        ]
+
+    async def list_cycles(self, limit: int = 50) -> builtins.list[dict[str, Any]]:
+        """List cycles (sprints) - Not supported in file-based AITrackdown.
+
+        Args:
+        ----
+            limit: Maximum number of cycles to return (unused)
+
+        Returns:
+        -------
+            Empty list (cycles not supported)
+
+        Note:
+        ----
+            AITrackdown is a simple file-based system without
+            cycle/sprint management. Returns empty list.
+
+        """
+        logger.info("list_cycles called but cycles not supported in AITrackdown")
+        return []
+
+    async def get_issue_status(self, ticket_id: str) -> dict[str, Any] | None:
+        """Get status details for a ticket.
+
+        Args:
+        ----
+            ticket_id: Ticket identifier
+
+        Returns:
+        -------
+            Status dictionary with:
+                - id: Ticket ID
+                - state: Current state
+                - priority: Current priority
+                - updated_at: Last update timestamp
+                - created_at: Creation timestamp
+                - title: Ticket title
+                - assignee: Assignee (if Task, None for Epic)
+            Returns None if ticket not found
+
+        Raises:
+        ------
+            ValueError: If ticket_id is invalid
+
+        """
+        if not ticket_id:
+            raise ValueError("ticket_id is required")
+
+        # Read ticket
+        ticket = await self.read(ticket_id)
+        if not ticket:
+            logger.warning("Ticket %s not found", ticket_id)
+            return None
+
+        # Return comprehensive status object
+        status = {
+            "id": ticket.id,
+            "state": ticket.state,
+            "priority": ticket.priority,
+            "updated_at": ticket.updated_at.isoformat() if ticket.updated_at else None,
+            "created_at": ticket.created_at.isoformat() if ticket.created_at else None,
+            "title": ticket.title,
+        }
+
+        # Add assignee only if ticket is a Task (Epic doesn't have assignee)
+        if hasattr(ticket, "assignee"):
+            status["assignee"] = ticket.assignee
+
+        return status
+
+    async def list_issue_statuses(self) -> builtins.list[dict[str, Any]]:
+        """List available ticket statuses.
+
+        Returns:
+        -------
+            List of status dictionaries with:
+                - id: State identifier
+                - name: Human-readable state name
+                - description: State description
+
+        Note:
+        ----
+            AITrackdown uses standard TicketState enum values:
+            open, in_progress, ready, tested, done, closed, waiting, blocked
+
+        """
+        # Return hardcoded list of TicketState values
+        statuses = [
+            {
+                "id": "open",
+                "name": "Open",
+                "description": "Ticket is created and ready to be worked on",
+            },
+            {
+                "id": "in_progress",
+                "name": "In Progress",
+                "description": "Ticket is actively being worked on",
+            },
+            {
+                "id": "ready",
+                "name": "Ready",
+                "description": "Ticket is ready for review or testing",
+            },
+            {
+                "id": "tested",
+                "name": "Tested",
+                "description": "Ticket has been tested and verified",
+            },
+            {
+                "id": "done",
+                "name": "Done",
+                "description": "Ticket work is completed",
+            },
+            {
+                "id": "closed",
+                "name": "Closed",
+                "description": "Ticket is closed and archived",
+            },
+            {
+                "id": "waiting",
+                "name": "Waiting",
+                "description": "Ticket is waiting for external dependency",
+            },
+            {
+                "id": "blocked",
+                "name": "Blocked",
+                "description": "Ticket is blocked by an issue or dependency",
+            },
+        ]
+        return statuses
+
 
 # Register the adapter
 AdapterRegistry.register("aitrackdown", AITrackdownAdapter)