kicad-sch-api 0.1.4__tar.gz → 0.1.5__tar.gz

{kicad_sch_api-0.1.4 → kicad_sch_api-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kicad-sch-api
-Version: 0.1.4
+Version: 0.1.5
 Summary: Professional KiCAD schematic manipulation library with exact format preservation and AI agent integration
 Author-email: Circuit-Synth <shane@circuit-synth.com>
 Maintainer-email: Circuit-Synth <shane@circuit-synth.com>

{kicad_sch_api-0.1.4 → kicad_sch_api-0.1.5}/kicad_sch_api/cli.py

@@ -323,6 +323,89 @@ def setup_everything() -> bool:
     
     return True
 
+def setup_daemon() -> bool:
+    """Setup with daemon-style MCP server (RECOMMENDED)."""
+    print("🚀 KiCAD Schematic API - Daemon Setup")
+    print("=" * 50)
+    print("This will set up a persistent MCP daemon that runs in the background.")
+    print()
+    
+    success = True
+    
+    # 1. Test installation
+    print("Step 1/5: Testing installation...")
+    if not test_installation():
+        print("❌ Installation test failed. Please reinstall the package.")
+        return False
+    print()
+    
+    # 2. Initialize cache
+    print("Step 2/5: Initializing component cache...")
+    if not init_cache():
+        print("⚠️  Cache initialization failed, but continuing...")
+    print()
+    
+    # 3. Start daemon
+    print("Step 3/5: Starting MCP daemon...")
+    from .daemon import MCPDaemon
+    daemon = MCPDaemon()
+    
+    if daemon.is_running():
+        print("✅ Daemon is already running")
+    else:
+        if not daemon.start():
+            print("❌ Failed to start daemon")
+            return False
+    print()
+    
+    # 4. Configure Claude Code
+    print("Step 4/5: Configuring Claude Code...")
+    if not daemon._update_claude_config():
+        print("⚠️  Claude Code configuration failed, but daemon is running...")
+    else:
+        print("✅ Claude Code configured successfully")
+    print()
+    
+    # 5. Create demo
+    print("Step 5/5: Creating demo schematic...")
+    if not create_demo():
+        print("⚠️  Demo creation failed, but setup is complete")
+    print()
+    
+    # Final status
+    status = daemon.get_status()
+    print("🎉 Daemon Setup Complete!")
+    print()
+    print("✨ What's new with daemon mode:")
+    print("  • MCP server runs persistently in background")
+    print("  • No PATH issues or virtual environment problems")
+    print("  • Automatic startup after system reboot (if desired)")
+    print("  • Better performance and reliability")
+    print()
+    print("📊 Status:")
+    print(f"  Daemon running: {'✅ Yes' if status['running'] else '❌ No'}")
+    print(f"  Claude configured: {'✅ Yes' if status['claude_configured'] else '❌ No'}")
+    print(f"  Log file: {status['log_file']}")
+    print()
+    
+    if status['running'] and status['claude_configured']:
+        print("🚀 Next steps:")
+        print("1. Restart Claude Code")
+        print("2. Try: 'Create a voltage divider with two 10kΩ resistors'")
+        print("3. Open demo_circuit.kicad_sch in KiCAD to see the example")
+        print()
+        print("🔧 Daemon management:")
+        print("  kicad-sch-api --daemon-status    # Check status")
+        print("  kicad-sch-api --stop-daemon      # Stop daemon")
+        print("  kicad-sch-api --start-daemon     # Start daemon")
+        print("  kicad-sch-api --restart-daemon   # Restart daemon")
+    else:
+        print("⚠️  Setup incomplete. Check the status and try again.")
+        return False
+    
+    print()
+    return True
+
 def main():
     """Main CLI entry point."""
     parser = argparse.ArgumentParser(
@@ -331,15 +414,32 @@ def main():
         epilog="""
 Examples:
   kicad-sch-api --setup                # Complete one-command setup (RECOMMENDED)
-  kicad-sch-api --setup-claude-code    # Configure Claude Code MCP only
-  kicad-sch-api --test                 # Test installation
-  kicad-sch-api --demo                 # Create demo schematic
-  kicad-sch-api --status               # Show detailed status
+  kicad-sch-api --setup-daemon          # Setup with daemon-style MCP server
+  kicad-sch-api --start-daemon          # Start MCP daemon in background
+  kicad-sch-api --stop-daemon           # Stop MCP daemon
+  kicad-sch-api --daemon-status         # Show daemon status
+  kicad-sch-api --test                  # Test installation
+  kicad-sch-api --demo                  # Create demo schematic
         """
     )
     
+    # Main setup options
     parser.add_argument('--setup', action='store_true',
                        help='Complete one-command setup (RECOMMENDED for new users)')
+    parser.add_argument('--setup-daemon', action='store_true',
+                       help='Setup with daemon-style MCP server (RECOMMENDED)')
+    
+    # Daemon management
+    parser.add_argument('--start-daemon', action='store_true',
+                       help='Start MCP daemon in background')
+    parser.add_argument('--stop-daemon', action='store_true',
+                       help='Stop MCP daemon')
+    parser.add_argument('--restart-daemon', action='store_true',
+                       help='Restart MCP daemon')
+    parser.add_argument('--daemon-status', action='store_true',
+                       help='Show daemon status and logs')
+    
+    # Legacy/manual setup options
     parser.add_argument('--setup-claude-code', action='store_true',
                        help='Configure Claude Code MCP settings only')
     parser.add_argument('--test', action='store_true',
@@ -357,21 +457,65 @@ Examples:
     
     args = parser.parse_args()
     
-    # If no arguments provided, suggest the simple setup
+    # If no arguments provided, suggest the daemon setup
     if not any(vars(args).values()):
-        print("KiCAD Schematic API - Command Line Interface")
+        print("🚀 KiCAD Schematic API - Command Line Interface")
+        print()
+        print("🌟 RECOMMENDED: Setup with daemon-style MCP server:")
+        print("  kicad-sch-api --setup-daemon")
         print()
-        print("For new users, run the complete setup:")
+        print("📖 For legacy setup:")
         print("  kicad-sch-api --setup")
         print()
-        print("For help with all options:")
+        print("🆘 For help with all options:")
         print("  kicad-sch-api --help")
         return
     
+    # Import daemon management after args check
+    from .daemon import MCPDaemon
+    
+    # Handle daemon commands
+    daemon = MCPDaemon()
+    
+    if args.start_daemon:
+        success = daemon.start()
+        sys.exit(0 if success else 1)
+    
+    if args.stop_daemon:
+        success = daemon.stop()
+        sys.exit(0 if success else 1)
+    
+    if args.restart_daemon:
+        success = daemon.restart()
+        sys.exit(0 if success else 1)
+    
+    if args.daemon_status:
+        status = daemon.get_status()
+        print(f"🚀 KiCAD Schematic MCP Server Status")
+        print("=" * 40)
+        print(f"Running: {'✅ Yes' if status['running'] else '❌ No'}")
+        
+        if status["pid"]:
+            print(f"PID: {status['pid']}")
+        
+        print(f"Log file: {status['log_file']}")
+        print(f"Claude configured: {'✅ Yes' if status['claude_configured'] else '❌ No'}")
+        
+        if not status["claude_configured"]:
+            print("\n⚠️  Claude Code not configured. Run with --setup-daemon to fix.")
+        
+        if status["running"]:
+            print("\n📜 Recent logs:")
+            daemon.show_logs(10)
+        
+        return
+    
     # Execute requested actions
     success = True
     
-    if args.setup:
+    if args.setup_daemon:
+        success &= setup_daemon()
+    elif args.setup:
         success &= setup_everything()
     
     if args.setup_claude_code:

kicad_sch_api-0.1.5/kicad_sch_api/daemon.py

@@ -0,0 +1,322 @@
+#!/usr/bin/env python3
+"""
+KiCAD Schematic API - MCP Server Daemon
+
+Provides daemon-style MCP server with proper process management.
+Users can start/stop/restart the server as a background process.
+"""
+
+import os
+import sys
+import signal
+import subprocess
+import time
+import json
+import logging
+from pathlib import Path
+from typing import Optional
+import tempfile
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+class MCPDaemon:
+    """Manages the MCP server as a daemon process."""
+    
+    def __init__(self):
+        self.name = "kicad-sch-mcp"
+        self.home_dir = Path.home()
+        self.config_dir = self.home_dir / ".kicad-sch-api"
+        self.config_dir.mkdir(exist_ok=True)
+        
+        # Daemon files
+        self.pid_file = self.config_dir / "mcp-daemon.pid"
+        self.log_file = self.config_dir / "mcp-daemon.log"
+        self.socket_file = self.config_dir / "mcp-daemon.sock"
+        
+        # Claude configuration
+        self.claude_config = self._get_claude_config_path()
+    
+    def _get_claude_config_path(self) -> Path:
+        """Get the Claude Code configuration file path for current platform."""
+        if sys.platform == "darwin":
+            return self.home_dir / "Library/Application Support/Claude/claude_desktop_config.json"
+        elif sys.platform == "win32":
+            return Path(os.environ["APPDATA"]) / "Claude/claude_desktop_config.json"
+        else:  # Linux and others
+            return self.home_dir / ".config/Claude/claude_desktop_config.json"
+    
+    def is_running(self) -> bool:
+        """Check if daemon is currently running."""
+        if not self.pid_file.exists():
+            return False
+        
+        try:
+            with open(self.pid_file) as f:
+                pid = int(f.read().strip())
+            
+            # Check if process is still alive
+            os.kill(pid, 0)
+            return True
+        except (ValueError, ProcessLookupError, OSError):
+            # PID file exists but process is dead, clean up
+            self.pid_file.unlink(missing_ok=True)
+            return False
+    
+    def get_status(self) -> dict:
+        """Get detailed daemon status."""
+        status = {
+            "running": self.is_running(),
+            "pid": None,
+            "log_file": str(self.log_file),
+            "socket_file": str(self.socket_file),
+            "claude_configured": self._check_claude_config()
+        }
+        
+        if status["running"] and self.pid_file.exists():
+            try:
+                with open(self.pid_file) as f:
+                    status["pid"] = int(f.read().strip())
+            except (ValueError, OSError):
+                pass
+        
+        return status
+    
+    def _check_claude_config(self) -> bool:
+        """Check if Claude Code is configured with our MCP server."""
+        if not self.claude_config.exists():
+            return False
+        
+        try:
+            with open(self.claude_config) as f:
+                config = json.load(f)
+            
+            servers = config.get("mcpServers", {})
+            return "kicad-sch-api" in servers
+        except (json.JSONDecodeError, OSError):
+            return False
+    
+    def start(self) -> bool:
+        """Start the daemon process."""
+        if self.is_running():
+            logger.info("Daemon is already running")
+            return True
+        
+        logger.info("Starting MCP daemon...")
+        
+        try:
+            # Create the daemon process using the MCP server entry point
+            cmd = [
+                sys.executable, "-m", "kicad_sch_api.mcp.server",
+                "--daemon",
+                "--log-file", str(self.log_file),
+                "--pid-file", str(self.pid_file)
+            ]
+            
+            # Start daemon process
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                stdin=subprocess.DEVNULL,
+                start_new_session=True
+            )
+            
+            # Give it a moment to start
+            time.sleep(2)
+            
+            # Check if it started successfully
+            if self.is_running():
+                logger.info(f"Daemon started successfully (PID: {process.pid})")
+                self._update_claude_config()
+                return True
+            else:
+                logger.error("Failed to start daemon")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Error starting daemon: {e}")
+            return False
+    
+    def stop(self) -> bool:
+        """Stop the daemon process."""
+        if not self.is_running():
+            logger.info("Daemon is not running")
+            return True
+        
+        try:
+            with open(self.pid_file) as f:
+                pid = int(f.read().strip())
+            
+            logger.info(f"Stopping daemon (PID: {pid})...")
+            
+            # Try graceful shutdown first
+            os.kill(pid, signal.SIGTERM)
+            
+            # Wait for graceful shutdown
+            for _ in range(10):
+                if not self.is_running():
+                    break
+                time.sleep(0.5)
+            
+            # Force kill if still running
+            if self.is_running():
+                logger.warning("Forcing daemon shutdown...")
+                os.kill(pid, signal.SIGKILL)
+                time.sleep(1)
+            
+            # Clean up files
+            self.pid_file.unlink(missing_ok=True)
+            self.socket_file.unlink(missing_ok=True)
+            
+            if self.is_running():
+                logger.error("Failed to stop daemon")
+                return False
+            else:
+                logger.info("Daemon stopped successfully")
+                return True
+                
+        except (ValueError, ProcessLookupError, OSError) as e:
+            logger.error(f"Error stopping daemon: {e}")
+            # Clean up stale files
+            self.pid_file.unlink(missing_ok=True)
+            self.socket_file.unlink(missing_ok=True)
+            return True
+    
+    def restart(self) -> bool:
+        """Restart the daemon process."""
+        logger.info("Restarting daemon...")
+        self.stop()
+        time.sleep(1)
+        return self.start()
+    
+    def _update_claude_config(self) -> bool:
+        """Update Claude Code configuration with daemon socket."""
+        try:
+            # Create directory if it doesn't exist
+            self.claude_config.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Read existing config or create new one
+            if self.claude_config.exists():
+                with open(self.claude_config) as f:
+                    config = json.load(f)
+            else:
+                config = {}
+            
+            # Ensure mcpServers section exists
+            if "mcpServers" not in config:
+                config["mcpServers"] = {}
+            
+            # Update our server configuration
+            config["mcpServers"]["kicad-sch-api"] = {
+                "command": sys.executable,
+                "args": ["-m", "kicad_sch_api.mcp.server"],
+                "env": {}
+            }
+            
+            # Write configuration back
+            with open(self.claude_config, 'w') as f:
+                json.dump(config, f, indent=2)
+            
+            logger.info(f"Updated Claude configuration: {self.claude_config}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to update Claude configuration: {e}")
+            return False
+    
+    def show_logs(self, lines: int = 20) -> None:
+        """Show recent daemon log entries."""
+        if not self.log_file.exists():
+            print("No log file found")
+            return
+        
+        try:
+            # Use tail-like functionality
+            with open(self.log_file) as f:
+                log_lines = f.readlines()
+            
+            # Show last N lines
+            for line in log_lines[-lines:]:
+                print(line.rstrip())
+                
+        except OSError as e:
+            logger.error(f"Error reading log file: {e}")
+
+# CLI functions for entry points
+def start_daemon():
+    """Entry point for starting daemon."""
+    daemon = MCPDaemon()
+    success = daemon.start()
+    sys.exit(0 if success else 1)
+
+def stop_daemon():
+    """Entry point for stopping daemon."""
+    daemon = MCPDaemon()
+    success = daemon.stop()
+    sys.exit(0 if success else 1)
+
+def restart_daemon():
+    """Entry point for restarting daemon."""
+    daemon = MCPDaemon()
+    success = daemon.restart()
+    sys.exit(0 if success else 1)
+
+def status_daemon():
+    """Entry point for daemon status."""
+    daemon = MCPDaemon()
+    status = daemon.get_status()
+    
+    print(f"🚀 KiCAD Schematic MCP Server Status")
+    print("=" * 40)
+    print(f"Running: {'✅ Yes' if status['running'] else '❌ No'}")
+    
+    if status["pid"]:
+        print(f"PID: {status['pid']}")
+    
+    print(f"Log file: {status['log_file']}")
+    print(f"Claude configured: {'✅ Yes' if status['claude_configured'] else '❌ No'}")
+    
+    if not status["claude_configured"]:
+        print("\n⚠️  Claude Code not configured. Run with --configure-claude to fix.")
+    
+    if status["running"]:
+        print("\n📜 Recent logs:")
+        daemon.show_logs(10)
+
+def main():
+    """Main daemon management interface."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="KiCAD Schematic MCP Daemon Manager")
+    parser.add_argument("--start", action="store_true", help="Start the daemon")
+    parser.add_argument("--stop", action="store_true", help="Stop the daemon")
+    parser.add_argument("--restart", action="store_true", help="Restart the daemon")
+    parser.add_argument("--status", action="store_true", help="Show daemon status")
+    parser.add_argument("--logs", type=int, default=20, help="Show recent log lines")
+    
+    args = parser.parse_args()
+    
+    daemon = MCPDaemon()
+    
+    if args.start:
+        success = daemon.start()
+        sys.exit(0 if success else 1)
+    elif args.stop:
+        success = daemon.stop()
+        sys.exit(0 if success else 1)
+    elif args.restart:
+        success = daemon.restart()
+        sys.exit(0 if success else 1)
+    elif args.status:
+        status_daemon()
+    else:
+        # No arguments, show status
+        status_daemon()
+
+if __name__ == "__main__":
+    main()

{kicad_sch_api-0.1.4 → kicad_sch_api-0.1.5}/kicad_sch_api/mcp/server.py

@@ -1459,21 +1459,32 @@ This hierarchical approach makes complex designs manageable and promotes reusabl
 def main():
     """Run the MCP server."""
     import argparse
+    import os
+    import signal
+    import atexit
+    import time
     
     parser = argparse.ArgumentParser(description="KiCAD Schematic MCP Server")
     parser.add_argument('--test', action='store_true', help='Run quick test and exit')
     parser.add_argument('--debug', action='store_true', help='Enable debug logging')
     parser.add_argument('--status', action='store_true', help='Show server status and exit')
     parser.add_argument('--version', action='store_true', help='Show version and exit')
+    parser.add_argument('--daemon', action='store_true', help='Run as daemon process')
+    parser.add_argument('--log-file', type=str, help='Log file path for daemon mode')
+    parser.add_argument('--pid-file', type=str, help='PID file path for daemon mode')
     
     args = parser.parse_args()
     
+    # Handle daemon mode
+    if args.daemon:
+        return run_daemon(args.log_file, args.pid_file, args.debug)
+    
     if args.debug:
         logging.getLogger().setLevel(logging.DEBUG)
         logger.debug("Debug logging enabled")
     
     if args.version:
-        print("KiCAD Schematic MCP Server v0.1.4")
+        print("KiCAD Schematic MCP Server v0.1.5")
         return
     
     if args.status:
@@ -1505,5 +1516,106 @@ def main():
         logger.error(f"Server error: {e}")
         sys.exit(1)
 
+def run_daemon(log_file: Optional[str] = None, pid_file: Optional[str] = None, debug: bool = False):
+    """Run the MCP server as a daemon process."""
+    import os
+    import sys
+    import signal
+    import atexit
+    from pathlib import Path
+    
+    # Default paths
+    if not log_file:
+        log_file = str(Path.home() / ".kicad-sch-api" / "mcp-daemon.log")
+    if not pid_file:
+        pid_file = str(Path.home() / ".kicad-sch-api" / "mcp-daemon.pid")
+    
+    # Ensure directory exists
+    Path(log_file).parent.mkdir(parents=True, exist_ok=True)
+    Path(pid_file).parent.mkdir(parents=True, exist_ok=True)
+    
+    # Daemonize process
+    try:
+        pid = os.fork()
+        if pid > 0:
+            # Exit parent process
+            sys.exit(0)
+    except OSError as e:
+        logger.error(f"Fork failed: {e}")
+        sys.exit(1)
+    
+    # Decouple from parent environment
+    os.chdir("/")
+    os.setsid()
+    os.umask(0)
+    
+    # Second fork
+    try:
+        pid = os.fork()
+        if pid > 0:
+            # Exit first child
+            sys.exit(0)
+    except OSError as e:
+        logger.error(f"Second fork failed: {e}")
+        sys.exit(1)
+    
+    # Redirect standard file descriptors
+    sys.stdout.flush()
+    sys.stderr.flush()
+    
+    # Redirect to log file
+    with open(log_file, 'a') as f:
+        os.dup2(f.fileno(), sys.stdout.fileno())
+        os.dup2(f.fileno(), sys.stderr.fileno())
+    
+    # Close stdin
+    with open(os.devnull, 'r') as f:
+        os.dup2(f.fileno(), sys.stdin.fileno())
+    
+    # Write PID file
+    with open(pid_file, 'w') as f:
+        f.write(str(os.getpid()))
+    
+    # Setup signal handlers for graceful shutdown
+    def cleanup():
+        """Clean up PID file on exit."""
+        try:
+            os.unlink(pid_file)
+        except OSError:
+            pass
+    
+    def signal_handler(signum, frame):
+        """Handle shutdown signals."""
+        logger.info(f"Received signal {signum}, shutting down daemon...")
+        cleanup()
+        sys.exit(0)
+    
+    signal.signal(signal.SIGTERM, signal_handler)
+    signal.signal(signal.SIGINT, signal_handler)
+    atexit.register(cleanup)
+    
+    # Configure logging for daemon
+    log_handler = logging.FileHandler(log_file)
+    log_handler.setFormatter(logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    ))
+    
+    # Remove existing handlers and add file handler
+    logger.handlers.clear()
+    logger.addHandler(log_handler)
+    logger.setLevel(logging.DEBUG if debug else logging.INFO)
+    
+    # Start the MCP server
+    logger.info("Starting KiCAD Schematic MCP Server daemon...")
+    logger.info(f"PID: {os.getpid()}")
+    logger.info(f"Log file: {log_file}")
+    
+    try:
+        mcp.run()
+    except Exception as e:
+        logger.error(f"Daemon error: {e}")
+        cleanup()
+        sys.exit(1)
+
 if __name__ == "__main__":
     main()

{kicad_sch_api-0.1.4 → kicad_sch_api-0.1.5}/kicad_sch_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kicad-sch-api
-Version: 0.1.4
+Version: 0.1.5
 Summary: Professional KiCAD schematic manipulation library with exact format preservation and AI agent integration
 Author-email: Circuit-Synth <shane@circuit-synth.com>
 Maintainer-email: Circuit-Synth <shane@circuit-synth.com>

{kicad_sch_api-0.1.4 → kicad_sch_api-0.1.5}/kicad_sch_api.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ examples/mcp_basic_example.py
 examples/mcp_integration.py
 kicad_sch_api/__init__.py
 kicad_sch_api/cli.py
+kicad_sch_api/daemon.py
 kicad_sch_api/py.typed
 kicad_sch_api.egg-info/PKG-INFO
 kicad_sch_api.egg-info/SOURCES.txt

kicad_sch_api-0.1.5/kicad_sch_api.egg-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+kicad-sch-api = kicad_sch_api.cli:main
+kicad-sch-daemon = kicad_sch_api.daemon:main
+kicad-sch-daemon-start = kicad_sch_api.daemon:start_daemon
+kicad-sch-daemon-status = kicad_sch_api.daemon:status_daemon
+kicad-sch-daemon-stop = kicad_sch_api.daemon:stop_daemon
+kicad-sch-mcp = kicad_sch_api.mcp.server:main

{kicad_sch_api-0.1.4 → kicad_sch_api-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kicad-sch-api"
-version = "0.1.4"
+version = "0.1.5"
 description = "Professional KiCAD schematic manipulation library with exact format preservation and AI agent integration"
 readme = "README.md"
 license = "MIT"
@@ -43,6 +43,12 @@ dependencies = [
 kicad-sch-api = "kicad_sch_api.cli:main"
 kicad-sch-mcp = "kicad_sch_api.mcp.server:main"
 
+# New daemon-style entry points
+kicad-sch-daemon = "kicad_sch_api.daemon:main"
+kicad-sch-daemon-start = "kicad_sch_api.daemon:start_daemon"
+kicad-sch-daemon-stop = "kicad_sch_api.daemon:stop_daemon"
+kicad-sch-daemon-status = "kicad_sch_api.daemon:status_daemon"
+
 [project.optional-dependencies]
 dev = [
     "pytest>=7.0.0",

kicad_sch_api-0.1.4/kicad_sch_api.egg-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-kicad-sch-api = kicad_sch_api.cli:main
-kicad-sch-mcp = kicad_sch_api.mcp.server:main