mcp-ticketer 0.1.30__py3-none-any.whl → 1.2.11__py3-none-any.whl

mcp_ticketer/core/project_config.py

@@ -14,7 +14,7 @@ import os
 from dataclasses import asdict, dataclass, field
 from enum import Enum
 from pathlib import Path
-from typing import Any, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional
 
 if TYPE_CHECKING:
     from .env_discovery import DiscoveryResult
@@ -47,29 +47,29 @@ class AdapterConfig:
     enabled: bool = True
 
     # Common fields (not all adapters use all fields)
-    api_key: Optional[str] = None
-    token: Optional[str] = None
+    api_key: str | None = None
+    token: str | None = None
 
     # Linear-specific
-    team_id: Optional[str] = None
-    team_key: Optional[str] = None
-    workspace: Optional[str] = None
+    team_id: str | None = None
+    team_key: str | None = None
+    workspace: str | None = None
 
     # JIRA-specific
-    server: Optional[str] = None
-    email: Optional[str] = None
-    api_token: Optional[str] = None
-    project_key: Optional[str] = None
+    server: str | None = None
+    email: str | None = None
+    api_token: str | None = None
+    project_key: str | None = None
 
     # GitHub-specific
-    owner: Optional[str] = None
-    repo: Optional[str] = None
+    owner: str | None = None
+    repo: str | None = None
 
     # AITrackdown-specific
-    base_path: Optional[str] = None
+    base_path: str | None = None
 
     # Project ID (can be used by any adapter for scoping)
-    project_id: Optional[str] = None
+    project_id: str | None = None
 
     # Additional adapter-specific configuration
     additional_config: dict[str, Any] = field(default_factory=dict)
@@ -126,9 +126,9 @@ class ProjectConfig:
     """Configuration for a specific project."""
 
     adapter: str
-    api_key: Optional[str] = None
-    project_id: Optional[str] = None
-    team_id: Optional[str] = None
+    api_key: str | None = None
+    project_id: str | None = None
+    team_id: str | None = None
     additional_config: dict[str, Any] = field(default_factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -147,7 +147,7 @@ class HybridConfig:
 
     enabled: bool = False
     adapters: list[str] = field(default_factory=list)
-    primary_adapter: Optional[str] = None
+    primary_adapter: str | None = None
     sync_strategy: SyncStrategy = SyncStrategy.PRIMARY_SOURCE
 
     def to_dict(self) -> dict[str, Any]:
@@ -167,16 +167,73 @@ class HybridConfig:
 
 @dataclass
 class TicketerConfig:
-    """Complete ticketer configuration with hierarchical resolution."""
+    """Complete ticketer configuration with hierarchical resolution.
+
+    Supports URL parsing for default_project field:
+    - Linear URLs: https://linear.app/workspace/project/project-slug-abc123
+    - JIRA URLs: https://company.atlassian.net/browse/PROJ-123
+    - GitHub URLs: https://github.com/owner/repo/projects/1
+    - Plain IDs: PROJ-123, abc-123, 1 (backward compatible)
+    """
 
     default_adapter: str = "aitrackdown"
     project_configs: dict[str, ProjectConfig] = field(default_factory=dict)
     adapters: dict[str, AdapterConfig] = field(default_factory=dict)
-    hybrid_mode: Optional[HybridConfig] = None
+    hybrid_mode: HybridConfig | None = None
+
+    # Default values for ticket operations
+    default_user: str | None = None  # Default assignee (user_id or email)
+    default_project: str | None = None  # Default project/epic ID (supports URLs)
+    default_epic: str | None = None  # Alias for default_project (backward compat)
+    default_tags: list[str] | None = None  # Default tags for new tickets
+    default_team: str | None = None  # Default team ID/key for multi-team platforms
+    default_cycle: str | None = None  # Default sprint/cycle ID for timeline scoping
+    assignment_labels: list[str] | None = None  # Labels indicating ticket assignment
+
+    def __post_init__(self):
+        """Normalize default_project if it's a URL."""
+        if self.default_project:
+            self.default_project = self._normalize_project_id(self.default_project)
+        if self.default_epic:
+            self.default_epic = self._normalize_project_id(self.default_epic)
+
+    def _normalize_project_id(self, value: str) -> str:
+        """Normalize project ID by extracting from URL if needed.
+
+        Args:
+            value: Project ID or URL
+
+        Returns:
+            Normalized project ID (plain ID, not URL)
+
+        Examples:
+            >>> config._normalize_project_id("PROJ-123")
+            'PROJ-123'
+            >>> config._normalize_project_id("https://linear.app/team/project/abc-123")
+            'abc-123'
+
+        """
+        from .url_parser import is_url, normalize_project_id
+
+        try:
+            # If it's a URL, use auto-detection (don't rely on default_adapter)
+            # This allows users to paste URLs from any platform
+            if is_url(value):
+                normalized = normalize_project_id(value, adapter_type=None)
+            else:
+                # For plain IDs, just return as-is
+                normalized = normalize_project_id(value, self.default_adapter)
+
+            logger.debug(f"Normalized '{value}' to '{normalized}'")
+            return normalized
+        except Exception as e:
+            # If normalization fails, log warning but keep original value
+            logger.warning(f"Failed to normalize project ID '{value}': {e}")
+            return value
 
     def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
-        return {
+        result = {
             "default_adapter": self.default_adapter,
             "project_configs": {
                 path: config.to_dict() for path, config in self.project_configs.items()
@@ -186,6 +243,22 @@ class TicketerConfig:
             },
             "hybrid_mode": self.hybrid_mode.to_dict() if self.hybrid_mode else None,
         }
+        # Add optional fields if set
+        if self.default_user is not None:
+            result["default_user"] = self.default_user
+        if self.default_project is not None:
+            result["default_project"] = self.default_project
+        if self.default_epic is not None:
+            result["default_epic"] = self.default_epic
+        if self.default_tags is not None:
+            result["default_tags"] = self.default_tags
+        if self.default_team is not None:
+            result["default_team"] = self.default_team
+        if self.default_cycle is not None:
+            result["default_cycle"] = self.default_cycle
+        if self.assignment_labels is not None:
+            result["assignment_labels"] = self.assignment_labels
+        return result
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> "TicketerConfig":
@@ -212,6 +285,13 @@ class TicketerConfig:
             project_configs=project_configs,
             adapters=adapters,
             hybrid_mode=hybrid_mode,
+            default_user=data.get("default_user"),
+            default_project=data.get("default_project"),
+            default_epic=data.get("default_epic"),
+            default_tags=data.get("default_tags"),
+            default_team=data.get("default_team"),
+            default_cycle=data.get("default_cycle"),
+            assignment_labels=data.get("assignment_labels"),
         )
 
 
@@ -219,29 +299,77 @@ class ConfigValidator:
     """Validate adapter configurations."""
 
     @staticmethod
-    def validate_linear_config(config: dict[str, Any]) -> tuple[bool, Optional[str]]:
+    def validate_linear_config(config: dict[str, Any]) -> tuple[bool, str | None]:
         """Validate Linear adapter configuration.
 
+        Args:
+            config: Linear configuration dictionary
+
         Returns:
             Tuple of (is_valid, error_message)
 
         """
+        import logging
+        import re
+
+        logger = logging.getLogger(__name__)
+
         required = ["api_key"]
-        for field in required:
-            if field not in config or not config[field]:
-                return False, f"Linear config missing required field: {field}"
+        missing_fields = []
+
+        for field_name in required:
+            if field_name not in config or not config[field_name]:
+                missing_fields.append(field_name)
 
-        # Require either team_key or team_id (team_id is preferred)
-        if not config.get("team_key") and not config.get("team_id"):
+        if missing_fields:
             return (
                 False,
-                "Linear config requires either team_key (short key like 'BTA') or team_id (UUID)",
+                f"Linear config missing required fields: {', '.join(missing_fields)}",
+            )
+
+        # Require either team_key or team_id (team_key is preferred)
+        has_team_key = config.get("team_key") and config["team_key"].strip()
+        has_team_id = config.get("team_id") and config["team_id"].strip()
+
+        if not has_team_key and not has_team_id:
+            return (
+                False,
+                "Linear config requires either team_key (short key like 'ENG') or team_id (UUID)",
+            )
+
+        # Validate team_id format if provided (should be UUID)
+        if has_team_id:
+            team_id = config["team_id"]
+            uuid_pattern = re.compile(
+                r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
+                re.IGNORECASE,
+            )
+
+            if not uuid_pattern.match(team_id):
+                # Not a UUID - could be a team_key mistakenly stored as team_id
+                logger.warning(
+                    f"team_id '{team_id}' is not a UUID format. "
+                    f"It will be treated as team_key and resolved at runtime."
+                )
+                # Move it to team_key if team_key is empty
+                if not has_team_key:
+                    config["team_key"] = team_id
+                    del config["team_id"]
+                    logger.info(f"Moved non-UUID team_id to team_key: {team_id}")
+
+        # Validate user_email format if provided
+        if config.get("user_email"):
+            email = config["user_email"]
+            email_pattern = re.compile(
+                r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
             )
+            if not email_pattern.match(email):
+                return False, f"Invalid email format for user_email: {email}"
 
         return True, None
 
     @staticmethod
-    def validate_github_config(config: dict[str, Any]) -> tuple[bool, Optional[str]]:
+    def validate_github_config(config: dict[str, Any]) -> tuple[bool, str | None]:
         """Validate GitHub adapter configuration.
 
         Returns:
@@ -263,14 +391,14 @@ class ConfigValidator:
 
         # Otherwise need explicit owner and repo
         required = ["owner", "repo"]
-        for field in required:
-            if field not in config or not config[field]:
-                return False, f"GitHub config missing required field: {field}"
+        for field_name in required:
+            if field_name not in config or not config[field_name]:
+                return False, f"GitHub config missing required field: {field_name}"
 
         return True, None
 
     @staticmethod
-    def validate_jira_config(config: dict[str, Any]) -> tuple[bool, Optional[str]]:
+    def validate_jira_config(config: dict[str, Any]) -> tuple[bool, str | None]:
         """Validate JIRA adapter configuration.
 
         Returns:
@@ -278,9 +406,9 @@ class ConfigValidator:
 
         """
         required = ["server", "email", "api_token"]
-        for field in required:
-            if field not in config or not config[field]:
-                return False, f"JIRA config missing required field: {field}"
+        for field_name in required:
+            if field_name not in config or not config[field_name]:
+                return False, f"JIRA config missing required field: {field_name}"
 
         # Validate server URL format
         server = config["server"]
@@ -292,7 +420,7 @@ class ConfigValidator:
     @staticmethod
     def validate_aitrackdown_config(
         config: dict[str, Any],
-    ) -> tuple[bool, Optional[str]]:
+    ) -> tuple[bool, str | None]:
         """Validate AITrackdown adapter configuration.
 
         Returns:
@@ -306,7 +434,7 @@ class ConfigValidator:
     @classmethod
     def validate(
         cls, adapter_type: str, config: dict[str, Any]
-    ) -> tuple[bool, Optional[str]]:
+    ) -> tuple[bool, str | None]:
         """Validate configuration for any adapter type.
 
         Args:
@@ -350,7 +478,7 @@ class ConfigResolver:
     PROJECT_CONFIG_SUBPATH = ".mcp-ticketer" / Path("config.json")
 
     def __init__(
-        self, project_path: Optional[Path] = None, enable_env_discovery: bool = True
+        self, project_path: Path | None = None, enable_env_discovery: bool = True
     ):
         """Initialize config resolver.
 
@@ -361,8 +489,8 @@ class ConfigResolver:
         """
         self.project_path = project_path or Path.cwd()
         self.enable_env_discovery = enable_env_discovery
-        self._project_config: Optional[TicketerConfig] = None
-        self._discovered_config: Optional[DiscoveryResult] = None
+        self._project_config: TicketerConfig | None = None
+        self._discovered_config: DiscoveryResult | None = None
 
     def load_global_config(self) -> TicketerConfig:
         """Load default configuration (global config loading removed for security).
@@ -382,8 +510,8 @@ class ConfigResolver:
         return default_config
 
     def load_project_config(
-        self, project_path: Optional[Path] = None
-    ) -> Optional[TicketerConfig]:
+        self, project_path: Path | None = None
+    ) -> TicketerConfig | None:
         """Load project-specific configuration.
 
         Args:
@@ -424,7 +552,7 @@ class ConfigResolver:
         self.save_project_config(config)
 
     def save_project_config(
-        self, config: TicketerConfig, project_path: Optional[Path] = None
+        self, config: TicketerConfig, project_path: Path | None = None
     ) -> None:
         """Save project-specific configuration.
 
@@ -461,8 +589,8 @@ class ConfigResolver:
 
     def resolve_adapter_config(
         self,
-        adapter_name: Optional[str] = None,
-        cli_overrides: Optional[dict[str, Any]] = None,
+        adapter_name: str | None = None,
+        cli_overrides: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         """Resolve adapter configuration with hierarchical precedence.
 
@@ -582,6 +710,12 @@ class ConfigResolver:
                 overrides["team_id"] = os.getenv("MCP_TICKETER_LINEAR_TEAM_ID")
             if os.getenv("LINEAR_API_KEY"):
                 overrides["api_key"] = os.getenv("LINEAR_API_KEY")
+            if os.getenv("LINEAR_TEAM_ID"):
+                overrides["team_id"] = os.getenv("LINEAR_TEAM_ID")
+            if os.getenv("LINEAR_TEAM_KEY"):
+                overrides["team_key"] = os.getenv("LINEAR_TEAM_KEY")
+            if os.getenv("MCP_TICKETER_LINEAR_TEAM_KEY"):
+                overrides["team_key"] = os.getenv("MCP_TICKETER_LINEAR_TEAM_KEY")
 
         elif adapter_type == AdapterType.GITHUB.value:
             if os.getenv("MCP_TICKETER_GITHUB_TOKEN"):
@@ -623,7 +757,7 @@ class ConfigResolver:
 
         return overrides
 
-    def get_hybrid_config(self) -> Optional[HybridConfig]:
+    def get_hybrid_config(self) -> HybridConfig | None:
         """Get hybrid mode configuration if enabled.
 
         Returns:
@@ -655,10 +789,10 @@ class ConfigResolver:
 
 
 # Singleton instance for global access
-_default_resolver: Optional[ConfigResolver] = None
+_default_resolver: ConfigResolver | None = None
 
 
-def get_config_resolver(project_path: Optional[Path] = None) -> ConfigResolver:
+def get_config_resolver(project_path: Path | None = None) -> ConfigResolver:
     """Get the global config resolver instance.
 
     Args:

mcp_ticketer/core/registry.py

@@ -1,6 +1,6 @@
 """Adapter registry for dynamic adapter management."""
 
-from typing import Any, Optional
+from typing import Any
 
 from .adapter import BaseAdapter
 
@@ -37,7 +37,7 @@ class AdapterRegistry:
 
     @classmethod
     def get_adapter(
-        cls, name: str, config: Optional[dict[str, Any]] = None, force_new: bool = False
+        cls, name: str, config: dict[str, Any] | None = None, force_new: bool = False
     ) -> BaseAdapter:
         """Get or create an adapter instance.
 
@@ -115,7 +115,7 @@ class AdapterRegistry:
 
 
 def adapter_factory(adapter_type: str, config: dict[str, Any]) -> BaseAdapter:
-    """Factory function for creating adapters.
+    """Create adapter instance using factory pattern.
 
     Args:
         adapter_type: Type of adapter to create

mcp_ticketer/core/session_state.py

@@ -0,0 +1,171 @@
+"""Session state management for tracking current ticket associations."""
+
+import json
+import logging
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Session timeout: 30 minutes of inactivity
+SESSION_TIMEOUT_MINUTES = 30
+SESSION_STATE_FILE = ".mcp-ticketer/session.json"
+
+
+@dataclass
+class SessionState:
+    """Track session-specific state for ticket associations."""
+
+    session_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    current_ticket: str | None = None  # Current ticket ID
+    ticket_opted_out: bool = False  # User explicitly chose "none"
+    last_activity: str = field(default_factory=lambda: datetime.now().isoformat())
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to dictionary."""
+        return {
+            "session_id": self.session_id,
+            "current_ticket": self.current_ticket,
+            "ticket_opted_out": self.ticket_opted_out,
+            "last_activity": self.last_activity,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "SessionState":
+        """Deserialize from dictionary."""
+        return cls(
+            session_id=data.get("session_id", str(uuid.uuid4())),
+            current_ticket=data.get("current_ticket"),
+            ticket_opted_out=data.get("ticket_opted_out", False),
+            last_activity=data.get("last_activity", datetime.now().isoformat()),
+        )
+
+    def is_expired(self) -> bool:
+        """Check if session has expired due to inactivity."""
+        try:
+            last_activity = datetime.fromisoformat(self.last_activity)
+            timeout = timedelta(minutes=SESSION_TIMEOUT_MINUTES)
+            return datetime.now() - last_activity > timeout
+        except (ValueError, TypeError):
+            # Invalid timestamp, consider expired
+            return True
+
+    def touch(self) -> None:
+        """Update last activity timestamp."""
+        self.last_activity = datetime.now().isoformat()
+
+
+class SessionStateManager:
+    """Manage session state persistence and lifecycle."""
+
+    def __init__(self, project_path: Path | None = None):
+        """Initialize session state manager.
+
+        Args:
+            project_path: Project root directory (defaults to current directory)
+
+        """
+        self.project_path = project_path or Path.cwd()
+        self.state_file = self.project_path / SESSION_STATE_FILE
+
+    def load_session(self) -> SessionState:
+        """Load session state from file.
+
+        Returns:
+            SessionState instance (creates new if expired or not found)
+
+        """
+        if not self.state_file.exists():
+            logger.debug("No session state file found, creating new session")
+            return SessionState()
+
+        try:
+            with open(self.state_file) as f:
+                data = json.load(f)
+
+            state = SessionState.from_dict(data)
+
+            # Check if session expired
+            if state.is_expired():
+                logger.info(
+                    f"Session {state.session_id} expired after "
+                    f"{SESSION_TIMEOUT_MINUTES} minutes, creating new session"
+                )
+                return SessionState()
+
+            # Touch to update activity
+            state.touch()
+            return state
+
+        except (json.JSONDecodeError, FileNotFoundError, KeyError) as e:
+            logger.warning(f"Failed to load session state: {e}, creating new session")
+            return SessionState()
+
+    def save_session(self, state: SessionState) -> None:
+        """Save session state to file.
+
+        Args:
+            state: SessionState to persist
+
+        """
+        try:
+            # Ensure directory exists
+            self.state_file.parent.mkdir(parents=True, exist_ok=True)
+
+            # Touch before saving
+            state.touch()
+
+            # Write state
+            with open(self.state_file, "w") as f:
+                json.dump(state.to_dict(), f, indent=2)
+
+            logger.debug(f"Saved session state: session_id={state.session_id}")
+
+        except Exception as e:
+            logger.error(f"Failed to save session state: {e}")
+
+    def clear_session(self) -> None:
+        """Clear session state (delete file)."""
+        try:
+            if self.state_file.exists():
+                self.state_file.unlink()
+                logger.info("Session state cleared")
+        except Exception as e:
+            logger.error(f"Failed to clear session state: {e}")
+
+    def get_current_ticket(self) -> str | None:
+        """Get current ticket for this session (convenience method).
+
+        Returns:
+            Current ticket ID or None
+
+        """
+        state = self.load_session()
+
+        # If user opted out, return None
+        if state.ticket_opted_out:
+            return None
+
+        return state.current_ticket
+
+    def set_current_ticket(self, ticket_id: str | None) -> None:
+        """Set current ticket for this session (convenience method).
+
+        Args:
+            ticket_id: Ticket ID to set (None to clear)
+
+        """
+        state = self.load_session()
+        state.current_ticket = ticket_id
+        state.ticket_opted_out = False  # Clear opt-out when setting ticket
+        self.save_session(state)
+
+    def opt_out_ticket(self) -> None:
+        """Mark that user doesn't want to associate work with a ticket (convenience method)."""
+        state = self.load_session()
+        state.current_ticket = None
+        state.ticket_opted_out = True
+        self.save_session(state)