feat: Fix tools, improve stability, and update docs

Author: madaerodog

.gitignore

@@ -2,6 +2,7 @@
 venv/
 env/
 ENV/
+.venv/
 
 # Environment files
 .env

README.md

@@ -71,9 +71,6 @@ KICAD_SEARCH_PATHS=~/pcb,~/Electronics,~/Projects/KiCad
 Once the environment is set up, you can run the server:
 
 ```bash
-# Run in development mode
-python -m mcp.dev main.py
-
 # Or run directly
 python main.py
 ```

docs/development.md

@@ -14,10 +14,9 @@ This guide provides detailed information for developers who want to modify or ex
    pip install -r requirements.txt
    ```
 
-2. **Run in development mode**:
+2. **Run the server**:
    ```bash
-   # Run with development server for better debugging
-   python -m mcp.dev main.py
+   python main.py
    ```
 
 3. **Use the MCP Inspector** for debugging:
@@ -240,11 +239,8 @@ To run tests:
 # Run all tests
 pytest
 
-# Run specific test file
-pytest tests/test_resources.py
-
-# Run with verbose output
-pytest -v
+# Run specific tests:
+pytest tests/test_tools.py::test_run_drc_check
 ```
 
 ## Debugging

docs/troubleshooting.md

@@ -175,10 +175,7 @@ This guide helps you troubleshoot common issues with the KiCad MCP Server.
 
 To diagnose issues, check the server logs:
 
-1. **Development Mode Logs**
-   - When running in development mode with `python -m mcp.dev main.py`, logs appear in the console
-
-2. **Claude Desktop Logs (macOS)**
+1. **Claude Desktop Logs (macOS)**
    - Server logs:
      ```bash
      tail -n 20 -F ~/Library/Logs/Claude/mcp-server-kicad.log
@@ -188,7 +185,7 @@ To diagnose issues, check the server logs:
      tail -n 20 -F ~/Library/Logs/Claude/mcp.log
      ```
 
-3. **Claude Desktop Logs (Windows)**
+2. **Claude Desktop Logs (Windows)**
    - Check logs in:
      ```
      %APPDATA%\Claude\Logs\
@@ -264,17 +261,12 @@ To diagnose issues, check the server logs:
 
 If you're still experiencing problems:
 
-1. Try running the server in development mode for more detailed output:
-   ```bash
-   python -m mcp.dev main.py
-   ```
-
-2. Use the MCP Inspector for direct server testing:
+1. Use the MCP Inspector for direct server testing:
    ```bash
    npx @modelcontextprotocol/inspector uv --directory . run main.py
    ```
 
-3. Open an issue on GitHub with:
+2. Open an issue on GitHub with:
    - A clear description of the problem
    - Steps to reproduce
    - Error messages or logs

kicad_mcp/config.py

@@ -16,7 +16,7 @@
     KICAD_USER_DIR = os.path.expanduser("~/Documents/KiCad")
     KICAD_APP_PATH = r"C:\Program Files\KiCad"
 elif system == "Linux":
-    KICAD_USER_DIR = os.path.expanduser("~/kicad")
+    KICAD_USER_DIR = os.path.expanduser("~/KiCad")
     KICAD_APP_PATH = "/usr/share/kicad"
 else:
     # Default to macOS paths if system is unknown

kicad_mcp/context.py

@@ -4,10 +4,13 @@
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from typing import AsyncIterator, Dict, Any
+import logging # Import logging
+import os # Added for PID
 
 from mcp.server.fastmcp import FastMCP
 
-from kicad_mcp.utils.python_path import setup_kicad_python_path
+# Get PID for logging
+# _PID = os.getpid()
 
 @dataclass
 class KiCadAppContext:
@@ -18,7 +21,7 @@ class KiCadAppContext:
     cache: Dict[str, Any]
 
 @asynccontextmanager
-async def kicad_lifespan(server: FastMCP) -> AsyncIterator[KiCadAppContext]:
+async def kicad_lifespan(server: FastMCP, kicad_modules_available: bool = False) -> AsyncIterator[KiCadAppContext]:
     """Manage KiCad MCP server lifecycle with type-safe context.
     
     This function handles:
@@ -28,58 +31,55 @@ async def kicad_lifespan(server: FastMCP) -> AsyncIterator[KiCadAppContext]:
     
     Args:
         server: The FastMCP server instance
+        kicad_modules_available: Flag indicating if Python modules were found (passed from create_server)
         
     Yields:
         KiCadAppContext: A typed context object shared across all handlers
     """
-    print("Starting KiCad MCP server initialization")
+    logging.info(f"Starting KiCad MCP server initialization")
 
-    # Initialize resources on startup
-    print("Setting up KiCad Python modules")
-    kicad_modules_available = setup_kicad_python_path()
-    print(f"KiCad Python modules available: {kicad_modules_available}")
+    # Resources initialization - Python path setup removed
+    # print("Setting up KiCad Python modules")
+    # kicad_modules_available = setup_kicad_python_path() # Now passed as arg
+    logging.info(f"KiCad Python module availability: {kicad_modules_available} (Setup logic removed)")
 
     # Create in-memory cache for expensive operations
     cache: Dict[str, Any] = {}
 
     # Initialize any other resources that need cleanup later
-    created_temp_dirs = []
+    created_temp_dirs = [] # Assuming this is managed elsewhere or not needed for now
 
     try:
-        # Import any KiCad modules that should be preloaded
-        if kicad_modules_available:
-            try:
-                print("Preloading KiCad Python modules")
-                
-                # Core PCB module used in multiple tools
-                import pcbnew
-                print(f"Successfully preloaded pcbnew module: {getattr(pcbnew, 'GetBuildVersion', lambda: 'unknown')()}")
-                cache["pcbnew_version"] = getattr(pcbnew, "GetBuildVersion", lambda: "unknown")()
-            except ImportError as e:
-                print(f"Failed to preload some KiCad modules: {str(e)}")
+        # --- Removed Python module preloading section --- 
+        # if kicad_modules_available:
+        #     try:
+        #         print("Preloading KiCad Python modules")
+        #         ...
+        #     except ImportError as e:
+        #         print(f"Failed to preload some KiCad modules: {str(e)}")
 
         # Yield the context to the server - server runs during this time
-        print("KiCad MCP server initialization complete")
+        logging.info(f"KiCad MCP server initialization complete")
         yield KiCadAppContext(
-            kicad_modules_available=kicad_modules_available,
+            kicad_modules_available=kicad_modules_available, # Pass the flag through
             cache=cache
         )
     finally:
         # Clean up resources when server shuts down
-        print("Shutting down KiCad MCP server")
+        logging.info(f"Shutting down KiCad MCP server")
 
         # Clear the cache
         if cache:
-            print(f"Clearing cache with {len(cache)} entries")
+            logging.info(f"Clearing cache with {len(cache)} entries")
             cache.clear()
 
         # Clean up any temporary directories
         import shutil
         for temp_dir in created_temp_dirs:
             try:
-                print(f"Removing temporary directory: {temp_dir}")
+                logging.info(f"Removing temporary directory: {temp_dir}")
                 shutil.rmtree(temp_dir, ignore_errors=True)
             except Exception as e:
-                print(f"Error cleaning up temporary directory {temp_dir}: {str(e)}")
+                logging.error(f"Error cleaning up temporary directory {temp_dir}: {str(e)}")
 
-        print("KiCad MCP server shutdown complete")
+        logging.info(f"KiCad MCP server shutdown complete")

kicad_mcp/resources/projects.py

@@ -15,22 +15,6 @@ def register_project_resources(mcp: FastMCP) -> None:
         mcp: The FastMCP server instance
     """
 
-    @mcp.resource("kicad://projects")
-    def list_projects_resource() -> str:
-        """List all KiCad projects as a formatted resource."""
-        projects = find_kicad_projects()
-        
-        if not projects:
-            return "No KiCad projects found in your Documents/KiCad directory."
-        
-        result = "# KiCad Projects\n\n"
-        for project in sorted(projects, key=lambda p: p["modified"], reverse=True):
-            result += f"## {project['name']}\n"
-            result += f"- **Path**: {project['path']}\n"
-            result += f"- **Last Modified**: {os.path.getmtime(project['path'])}\n\n"
-        
-        return result
-
     @mcp.resource("kicad://project/{project_path}")
     def get_project_details(project_path: str) -> str:
         """Get details about a specific KiCad project."""

kicad_mcp/server.py

@@ -4,6 +4,7 @@
 import atexit
 import os
 import signal
+import logging
 from typing import Callable
 from mcp.server.fastmcp import FastMCP
 
@@ -31,9 +32,6 @@
 from kicad_mcp.prompts.bom_prompts import register_bom_prompts
 from kicad_mcp.prompts.pattern_prompts import register_pattern_prompts
 
-# Import utils
-from kicad_mcp.utils.python_path import setup_kicad_python_path
-
 # Import context management
 from kicad_mcp.context import kicad_lifespan
 
@@ -56,7 +54,7 @@ def add_cleanup_handler(handler: Callable) -> None:
 
 def run_cleanup_handlers() -> None:
     """Run all registered cleanup handlers."""
-    print("Running cleanup handlers...")
+    logging.info(f"Running cleanup handlers...")
 
     global _shutting_down
 
@@ -65,28 +63,26 @@ def run_cleanup_handlers() -> None:
         return
 
     _shutting_down = True
-    print("Running cleanup handlers...")
+    logging.info(f"Running cleanup handlers...")
 
     for handler in cleanup_handlers:
         try:
             handler()
-            print(f"Cleanup handler {handler.__name__} completed successfully")
+            logging.info(f"Cleanup handler {handler.__name__} completed successfully")
         except Exception as e:
-            print(f"Error in cleanup handler {handler.__name__}: {str(e)}", exc_info=True)
+            logging.error(f"Error in cleanup handler {handler.__name__}: {str(e)}", exc_info=True)
 
 def shutdown_server():
     """Properly shutdown the server if it exists."""
     global _server_instance
 
     if _server_instance:
         try:
-            print("Shutting down KiCad MCP server")
-            # The server should handle its own shutdown through its lifespan context
-            # This is mostly a placeholder for any additional server shutdown code
+            logging.info(f"Shutting down KiCad MCP server")
             _server_instance = None
-            print("KiCad MCP server shutdown complete")
+            logging.info(f"KiCad MCP server shutdown complete")
         except Exception as e:
-            print(f"Error shutting down server: {str(e)}", exc_info=True)
+            logging.error(f"Error shutting down server: {str(e)}", exc_info=True)
 
 
 def register_signal_handlers(server: FastMCP) -> None:
@@ -96,7 +92,7 @@ def register_signal_handlers(server: FastMCP) -> None:
         server: The FastMCP server instance
     """
     def handle_exit_signal(signum, frame):
-        print(f"Received signal {signum}, initiating shutdown...")
+        logging.info(f"Received signal {signum}, initiating shutdown...")
 
         # Run cleanup first
         run_cleanup_handlers()
@@ -111,30 +107,33 @@ def handle_exit_signal(signum, frame):
     for sig in (signal.SIGINT, signal.SIGTERM):
         try:
             signal.signal(sig, handle_exit_signal)
-            print(f"Registered handler for signal {sig}")
+            logging.info(f"Registered handler for signal {sig}")
         except (ValueError, AttributeError) as e:
             # Some signals may not be available on all platforms
-            print(f"Could not register handler for signal {sig}: {str(e)}")
+            logging.error(f"Could not register handler for signal {sig}: {str(e)}")
 
 
 def create_server() -> FastMCP:
     """Create and configure the KiCad MCP server."""
-    print("Initializing KiCad MCP server")
+    logging.info(f"Initializing KiCad MCP server")
 
-    # Try to set up KiCad Python path
-    kicad_modules_available = setup_kicad_python_path()
+    # Try to set up KiCad Python path - Removed
+    # kicad_modules_available = setup_kicad_python_path()
+    kicad_modules_available = False # Set to False as we removed the setup logic
 
-    if kicad_modules_available:
-        print("KiCad Python modules successfully configured")
-    else:
-        print("KiCad Python modules not available - some features will be disabled")
+    # if kicad_modules_available:
+    #     print("KiCad Python modules successfully configured")
+    # else:
+    # Always print this now, as we rely on CLI
+    logging.info(f"KiCad Python module setup removed; relying on kicad-cli for external operations.")
 
     # Initialize FastMCP server
-    mcp = FastMCP("KiCad", lifespan=kicad_lifespan)
-    print("Created FastMCP server instance with lifespan management")
+    # Pass the availability flag (always False now) to the lifespan context
+    mcp = FastMCP("KiCad", lifespan=kicad_lifespan, lifespan_kwargs={"kicad_modules_available": kicad_modules_available})
+    logging.info(f"Created FastMCP server instance with lifespan management")
 
     # Register resources
-    print("Registering resources...")
+    logging.info(f"Registering resources...")
     register_project_resources(mcp)
     register_file_resources(mcp)
     register_drc_resources(mcp)
@@ -143,7 +142,7 @@ def create_server() -> FastMCP:
     register_pattern_resources(mcp)
 
     # Register tools
-    print("Registering tools...")
+    logging.info(f"Registering tools...")
     register_project_tools(mcp)
     register_analysis_tools(mcp)
     register_export_tools(mcp)
@@ -153,7 +152,7 @@ def create_server() -> FastMCP:
     register_pattern_tools(mcp)
 
     # Register prompts
-    print("Registering prompts...")
+    logging.info(f"Registering prompts...")
     register_prompts(mcp)
     register_drc_prompts(mcp)
     register_bom_prompts(mcp)
@@ -164,7 +163,7 @@ def create_server() -> FastMCP:
     atexit.register(run_cleanup_handlers)
 
     # Add specific cleanup handlers
-    add_cleanup_handler(lambda: print("KiCad MCP server shutdown complete"))
+    add_cleanup_handler(lambda: logging.info(f"KiCad MCP server shutdown complete"))
 
     # Add temp directory cleanup
     def cleanup_temp_dirs():
@@ -173,17 +172,17 @@ def cleanup_temp_dirs():
         from kicad_mcp.utils.temp_dir_manager import get_temp_dirs
 
         temp_dirs = get_temp_dirs()
-        print(f"Cleaning up {len(temp_dirs)} temporary directories")
+        logging.info(f"Cleaning up {len(temp_dirs)} temporary directories")
 
         for temp_dir in temp_dirs:
             try:
                 if os.path.exists(temp_dir):
                     shutil.rmtree(temp_dir, ignore_errors=True)
-                    print(f"Removed temporary directory: {temp_dir}")
+                    logging.info(f"Removed temporary directory: {temp_dir}")
             except Exception as e:
-                print(f"Error cleaning up temporary directory {temp_dir}: {str(e)}")
+                logging.error(f"Error cleaning up temporary directory {temp_dir}: {str(e)}")
 
     add_cleanup_handler(cleanup_temp_dirs)
 
-    print("Server initialization complete")
+    logging.info(f"Server initialization complete")
     return mcp

kicad_mcp/tools/bom_tools.py

@@ -584,7 +584,8 @@ async def export_bom_with_python(schematic_file: str, output_dir: str, project_n
         # Try to import KiCad Python modules
         # This is a placeholder since exporting BOMs from schematic files
         # is complex and KiCad's API for this is not well-documented
-        import pcbnew
+        import kicad
+        import kicad.pcbnew
 
         # For now, return a message indicating this method is not implemented yet
         print("BOM export with Python modules not fully implemented")