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

mcp_ticketer/mcp/server/main.py

@@ -48,23 +48,6 @@ from .dto import (
 )
 from .response_builder import ResponseBuilder
 
-# Load environment variables early (prioritize .env.local)
-# Check for .env.local first (takes precedence)
-env_local_file = Path.cwd() / ".env.local"
-if env_local_file.exists():
-    load_dotenv(env_local_file, override=True)
-    sys.stderr.write(f"[MCP Server] Loaded environment from: {env_local_file}\n")
-else:
-    # Fall back to .env
-    env_file = Path.cwd() / ".env"
-    if env_file.exists():
-        load_dotenv(env_file, override=True)
-        sys.stderr.write(f"[MCP Server] Loaded environment from: {env_file}\n")
-    else:
-        # Try default dotenv loading (searches upward)
-        load_dotenv(override=True)
-        sys.stderr.write("[MCP Server] Loaded environment from default search path\n")
-
 
 class MCPTicketServer:
     """MCP server for ticket operations over stdio - synchronous implementation."""
@@ -1050,8 +1033,8 @@ class MCPTicketServer:
         await self.adapter.close()
 
 
-async def main():
-    """Main entry point for MCP server - kept for backward compatibility.
+async def main() -> None:
+    """Run main entry point for MCP server - kept for backward compatibility.
 
     This function is maintained in case it's being called directly,
     but the preferred way is now through the CLI: `mcp-ticketer mcp`
@@ -1063,62 +1046,94 @@ async def main():
     # Load configuration
     import json
     import logging
-    from pathlib import Path
 
     logger = logging.getLogger(__name__)
 
+    # Load environment variables AFTER working directory has been set by __main__.py
+    # This ensures we load .env files from the target project directory, not from where the command is executed
+    env_local_file = Path.cwd() / ".env.local"
+    if env_local_file.exists():
+        load_dotenv(env_local_file, override=True)
+        sys.stderr.write(f"[MCP Server] Loaded environment from: {env_local_file}\n")
+        logger.debug(f"Loaded environment from: {env_local_file}")
+    else:
+        # Fall back to .env
+        env_file = Path.cwd() / ".env"
+        if env_file.exists():
+            load_dotenv(env_file, override=True)
+            sys.stderr.write(f"[MCP Server] Loaded environment from: {env_file}\n")
+            logger.debug(f"Loaded environment from: {env_file}")
+        else:
+            # Try default dotenv loading (searches upward)
+            load_dotenv(override=True)
+            sys.stderr.write(
+                "[MCP Server] Loaded environment from default search path\n"
+            )
+            logger.debug("Loaded environment from default search path")
+
     # Initialize defaults
     adapter_type = "aitrackdown"
     adapter_config = {"base_path": DEFAULT_BASE_PATH}
 
-    # Priority 1: Check .env files (highest priority for MCP)
-    env_config = _load_env_configuration()
-    if env_config and env_config.get("adapter_type"):
-        adapter_type = env_config["adapter_type"]
-        adapter_config = env_config["adapter_config"]
-        logger.info(f"Using adapter from .env files: {adapter_type}")
-        logger.info(f"Built adapter config from .env: {list(adapter_config.keys())}")
-    else:
-        # Priority 2: Check project-local config file
-        config_file = Path.cwd() / ".mcp-ticketer" / "config.json"
-        if config_file.exists():
-            # Validate config is within project
-            try:
-                if not config_file.resolve().is_relative_to(Path.cwd().resolve()):
-                    logger.error(
-                        f"Security violation: Config file {config_file} "
-                        "is not within project directory"
-                    )
-                    raise ValueError(
-                        f"Security violation: Config file {config_file} "
-                        "is not within project directory"
-                    )
-            except (ValueError, RuntimeError):
-                # is_relative_to may raise ValueError in some cases
-                pass
+    # Priority 1: Check project-local config file (highest priority)
+    config_file = Path.cwd() / ".mcp-ticketer" / "config.json"
+    config_loaded = False
 
-            try:
-                with open(config_file) as f:
-                    config = json.load(f)
-                    adapter_type = config.get("default_adapter", "aitrackdown")
-                    # Get adapter-specific config
-                    adapters_config = config.get("adapters", {})
-                    adapter_config = adapters_config.get(adapter_type, {})
-                    # Fallback to legacy config format
-                    if not adapter_config and "config" in config:
-                        adapter_config = config["config"]
-                    logger.info(
-                        f"Loaded MCP configuration from project-local: {config_file}"
-                    )
-            except (OSError, json.JSONDecodeError) as e:
-                logger.warning(f"Could not load project config: {e}, using defaults")
-                adapter_type = "aitrackdown"
-                adapter_config = {"base_path": DEFAULT_BASE_PATH}
-        else:
-            # Priority 3: Default to aitrackdown
-            logger.info("No configuration found, defaulting to aitrackdown adapter")
-            adapter_type = "aitrackdown"
-            adapter_config = {"base_path": DEFAULT_BASE_PATH}
+    if config_file.exists():
+        # Validate config is within project
+        try:
+            if not config_file.resolve().is_relative_to(Path.cwd().resolve()):
+                logger.error(
+                    f"Security violation: Config file {config_file} "
+                    "is not within project directory"
+                )
+                raise ValueError(
+                    f"Security violation: Config file {config_file} "
+                    "is not within project directory"
+                )
+        except (ValueError, RuntimeError):
+            # is_relative_to may raise ValueError in some cases
+            pass
+
+        try:
+            with open(config_file) as f:
+                config = json.load(f)
+                adapter_type = config.get("default_adapter", "aitrackdown")
+                # Get adapter-specific config
+                adapters_config = config.get("adapters", {})
+                adapter_config = adapters_config.get(adapter_type, {})
+                # Fallback to legacy config format
+                if not adapter_config and "config" in config:
+                    adapter_config = config["config"]
+                config_loaded = True
+                logger.info(
+                    f"Loaded MCP configuration from project-local: {config_file}"
+                )
+                sys.stderr.write(
+                    f"[MCP Server] Using adapter from config: {adapter_type}\n"
+                )
+        except (OSError, json.JSONDecodeError) as e:
+            logger.warning(f"Could not load project config: {e}, will try .env files")
+
+    # Priority 2: Check .env files (only if no config file found)
+    if not config_loaded:
+        env_config = _load_env_configuration()
+        if env_config and env_config.get("adapter_type"):
+            adapter_type = env_config["adapter_type"]
+            adapter_config = env_config["adapter_config"]
+            config_loaded = True
+            logger.info(f"Using adapter from .env files: {adapter_type}")
+            logger.info(
+                f"Built adapter config from .env: {list(adapter_config.keys())}"
+            )
+            sys.stderr.write(f"[MCP Server] Using adapter from .env: {adapter_type}\n")
+
+    # Priority 3: Default to aitrackdown
+    if not config_loaded:
+        logger.info("No configuration found, defaulting to aitrackdown adapter")
+        sys.stderr.write("[MCP Server] No config found, using default: aitrackdown\n")
+        adapter_type = "aitrackdown"
+        adapter_config = {"base_path": DEFAULT_BASE_PATH}
 
     # Log final configuration for debugging
     logger.info(f"Starting MCP server with adapter: {adapter_type}")
@@ -1138,8 +1153,6 @@ def _load_env_configuration() -> dict[str, Any] | None:
         Dictionary with 'adapter_type' and 'adapter_config' keys, or None if no config found
 
     """
-    from pathlib import Path
-
     # Check for .env files in order of preference
     env_files = [".env.local", ".env"]
     env_vars = {}

mcp_ticketer/mcp/server/tools/__init__.py

@@ -12,6 +12,9 @@ Modules:
     comment_tools: Comment management
     pr_tools: Pull request integration
     attachment_tools: File attachment handling
+    instruction_tools: Ticket instructions management
+    config_tools: Configuration management (adapter, project, user settings)
+    user_ticket_tools: User-specific ticket operations (my tickets, transitions)
 
 """
 
@@ -21,10 +24,13 @@ from . import (
     attachment_tools,  # noqa: F401
     bulk_tools,  # noqa: F401
     comment_tools,  # noqa: F401
+    config_tools,  # noqa: F401
     hierarchy_tools,  # noqa: F401
+    instruction_tools,  # noqa: F401
     pr_tools,  # noqa: F401
     search_tools,  # noqa: F401
     ticket_tools,  # noqa: F401
+    user_ticket_tools,  # noqa: F401
 )
 
 __all__ = [
@@ -35,4 +41,7 @@ __all__ = [
     "comment_tools",
     "pr_tools",
     "attachment_tools",
+    "instruction_tools",
+    "config_tools",
+    "user_ticket_tools",
 ]

mcp_ticketer/mcp/server/tools/attachment_tools.py

@@ -5,9 +5,11 @@ attachment information. Note that file attachment functionality may not be
 available in all adapters.
 """
 
+import mimetypes
+from pathlib import Path
 from typing import Any
 
-from ....core.models import Comment
+from ....core.models import Comment, TicketType
 from ..server_sdk import get_adapter, mcp
 
 
@@ -34,7 +36,7 @@ async def ticket_attach(
     try:
         adapter = get_adapter()
 
-        # Read ticket to validate it exists
+        # Read ticket to validate it exists and determine type
         ticket = await adapter.read(ticket_id)
         if ticket is None:
             return {
@@ -42,27 +44,72 @@ async def ticket_attach(
                 "error": f"Ticket {ticket_id} not found",
             }
 
-        # Check if adapter supports attachments
-        if not hasattr(adapter, "add_attachment"):
+        # Check if file exists
+        file_path_obj = Path(file_path)
+        if not file_path_obj.exists():
             return {
                 "status": "error",
-                "error": f"File attachments not supported by {type(adapter).__name__} adapter",
+                "error": f"File not found: {file_path}",
                 "ticket_id": ticket_id,
-                "note": "Consider using ticket_comment to add a reference to the file location",
             }
 
-        # Add attachment via adapter
-        attachment = await adapter.add_attachment(  # type: ignore
-            ticket_id=ticket_id, file_path=file_path, description=description
-        )
+        # Try Linear-specific upload methods first (most advanced)
+        if hasattr(adapter, "upload_file") and hasattr(adapter, "attach_file_to_issue"):
+            try:
+                # Determine MIME type
+                mime_type = mimetypes.guess_type(file_path)[0]
+
+                # Upload file to Linear's storage
+                file_url = await adapter.upload_file(file_path, mime_type)  # type: ignore
+
+                # Determine ticket type and attach accordingly
+                ticket_type = getattr(ticket, "ticket_type", None)
+                filename = file_path_obj.name
+
+                if ticket_type == TicketType.EPIC and hasattr(
+                    adapter, "attach_file_to_epic"
+                ):
+                    # Attach to epic (project)
+                    result = await adapter.attach_file_to_epic(  # type: ignore
+                        epic_id=ticket_id,
+                        file_url=file_url,
+                        title=description or filename,
+                        subtitle=f"Uploaded file: {filename}",
+                    )
+                else:
+                    # Attach to issue/task
+                    result = await adapter.attach_file_to_issue(  # type: ignore
+                        issue_id=ticket_id,
+                        file_url=file_url,
+                        title=description or filename,
+                        subtitle=f"Uploaded file: {filename}",
+                        comment_body=description if description else None,
+                    )
+
+                return {
+                    "status": "completed",
+                    "ticket_id": ticket_id,
+                    "method": "linear_native_upload",
+                    "file_url": file_url,
+                    "attachment": result,
+                }
+            except Exception:
+                # Fall through to legacy method if Linear-specific upload fails
+                pass
+
+        # Try legacy add_attachment method
+        if hasattr(adapter, "add_attachment"):
+            attachment = await adapter.add_attachment(  # type: ignore
+                ticket_id=ticket_id, file_path=file_path, description=description
+            )
 
-        return {
-            "status": "completed",
-            "ticket_id": ticket_id,
-            "attachment": attachment,
-        }
+            return {
+                "status": "completed",
+                "ticket_id": ticket_id,
+                "method": "adapter_native",
+                "attachment": attachment,
+            }
 
-    except AttributeError:
         # Fallback: Add file reference as comment
         comment_text = f"Attachment: {file_path}"
         if description: