kicad-sch-api 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

kicad_sch_api/__init__.py

@@ -42,7 +42,7 @@ Advanced Usage:
         print(f"Found {len(issues)} validation issues")
 """
 
-__version__ = "0.0.1"
+__version__ = "0.0.2"
 __author__ = "Circuit-Synth"
 __email__ = "info@circuit-synth.com"
 
@@ -54,7 +54,7 @@ from .library.cache import SymbolLibraryCache, get_symbol_cache
 from .utils.validation import ValidationError, ValidationIssue
 
 # Version info
-VERSION_INFO = (0, 0, 1)
+VERSION_INFO = (0, 0, 2)
 
 # Public API
 __all__ = [

kicad_sch_api/core/components.py

@@ -471,9 +471,13 @@ class ComponentCollection:
         matching = self.filter(**criteria)
 
         for component in matching:
-            # Update basic properties
+            # Update basic properties and handle special cases
             for key, value in updates.items():
-                if hasattr(component, key):
+                if key == 'properties' and isinstance(value, dict):
+                    # Handle properties dictionary specially
+                    for prop_name, prop_value in value.items():
+                        component.set_property(prop_name, str(prop_value))
+                elif hasattr(component, key) and key not in ['properties']:
                     setattr(component, key, value)
                 else:
                     # Add as custom property

kicad_sch_api/core/parser.py

@@ -200,7 +200,7 @@ class SExpressionParser:
             element_type = str(item[0]) if isinstance(item[0], sexpdata.Symbol) else None
 
             if element_type == "version":
-                schematic_data["version"] = item[1] if len(item) > 1 else None
+                schematic_data["version"] = str(item[1]) if len(item) > 1 else None
             elif element_type == "generator":
                 schematic_data["generator"] = item[1] if len(item) > 1 else None
             elif element_type == "uuid":
@@ -244,9 +244,9 @@ class SExpressionParser:
         if schematic_data.get("title_block"):
             sexp_data.append(self._title_block_to_sexp(schematic_data["title_block"]))
 
-        # Add lib_symbols
-        if schematic_data.get("lib_symbols"):
-            sexp_data.append(self._lib_symbols_to_sexp(schematic_data["lib_symbols"]))
+        # Add lib_symbols (always include for KiCAD compatibility)
+        lib_symbols = schematic_data.get("lib_symbols", {})
+        sexp_data.append(self._lib_symbols_to_sexp(lib_symbols))
 
         # Add components
         for component in schematic_data.get("components", []):
@@ -264,6 +264,11 @@ class SExpressionParser:
         for label in schematic_data.get("labels", []):
             sexp_data.append(self._label_to_sexp(label))
 
+        # Add symbol_instances (required by KiCAD)
+        symbol_instances = schematic_data.get("symbol_instances", [])
+        if symbol_instances or schematic_data.get("components"):
+            sexp_data.append([sexpdata.Symbol("symbol_instances")])
+
         return sexp_data
 
     def _parse_title_block(self, item: List[Any]) -> Dict[str, Any]:
@@ -321,7 +326,11 @@ class SExpressionParser:
                         elif prop_name == "Footprint":
                             symbol_data["footprint"] = prop_data.get("value")
                         else:
-                            symbol_data["properties"][prop_name] = prop_data.get("value")
+                            # Unescape quotes in property values when loading
+                            prop_value = prop_data.get("value")
+                            if prop_value:
+                                prop_value = str(prop_value).replace('\\"', '"')
+                            symbol_data["properties"][prop_name] = prop_value
                 elif element_type == "in_bom":
                     symbol_data["in_bom"] = sub_item[1] == "yes" if len(sub_item) > 1 else True
                 elif element_type == "on_board":
@@ -379,13 +388,15 @@ class SExpressionParser:
         if symbol_data.get("lib_id"):
             sexp.append([sexpdata.Symbol("lib_id"), symbol_data["lib_id"]])
 
-        # Add position and rotation
+        # Add position and rotation (preserve original format)
         pos = symbol_data.get("position", Point(0, 0))
         rotation = symbol_data.get("rotation", 0)
-        if rotation != 0:
-            sexp.append([sexpdata.Symbol("at"), pos.x, pos.y, rotation])
-        else:
-            sexp.append([sexpdata.Symbol("at"), pos.x, pos.y])
+        # Format numbers as integers if they are whole numbers
+        x = int(pos.x) if pos.x == int(pos.x) else pos.x
+        y = int(pos.y) if pos.y == int(pos.y) else pos.y
+        r = int(rotation) if rotation == int(rotation) else rotation
+        # Always include rotation for format consistency with KiCAD
+        sexp.append([sexpdata.Symbol("at"), x, y, r])
 
         if symbol_data.get("uuid"):
             sexp.append([sexpdata.Symbol("uuid"), symbol_data["uuid"]])
@@ -395,11 +406,14 @@ class SExpressionParser:
             sexp.append([sexpdata.Symbol("property"), "Reference", symbol_data["reference"]])
         if symbol_data.get("value"):
             sexp.append([sexpdata.Symbol("property"), "Value", symbol_data["value"]])
-        if symbol_data.get("footprint"):
-            sexp.append([sexpdata.Symbol("property"), "Footprint", symbol_data["footprint"]])
+        footprint = symbol_data.get("footprint")
+        if footprint is not None:  # Include empty strings but not None
+            sexp.append([sexpdata.Symbol("property"), "Footprint", footprint])
 
         for prop_name, prop_value in symbol_data.get("properties", {}).items():
-            sexp.append([sexpdata.Symbol("property"), prop_name, prop_value])
+            # Escape quotes in property values for proper S-expression format
+            escaped_value = str(prop_value).replace('"', '\\"')
+            sexp.append([sexpdata.Symbol("property"), prop_name, escaped_value])
 
         # Add BOM and board settings
         sexp.append([sexpdata.Symbol("in_bom"), "yes" if symbol_data.get("in_bom", True) else "no"])
@@ -426,8 +440,16 @@ class SExpressionParser:
 
     def _lib_symbols_to_sexp(self, lib_symbols: Dict[str, Any]) -> List[Any]:
         """Convert lib_symbols to S-expression."""
-        # Implementation for lib_symbols conversion
-        return [sexpdata.Symbol("lib_symbols")]
+        sexp = [sexpdata.Symbol("lib_symbols")]
+        
+        # Add each symbol definition
+        for symbol_name, symbol_def in lib_symbols.items():
+            if isinstance(symbol_def, dict):
+                symbol_sexp = [sexpdata.Symbol("symbol"), symbol_name]
+                # Add symbol definition details (for now, basic structure)
+                sexp.append(symbol_sexp)
+        
+        return sexp
 
     def get_validation_issues(self) -> List[ValidationIssue]:
         """Get list of validation issues from last parse operation."""

kicad_sch_api/utils/validation.py

@@ -87,7 +87,7 @@ class SchematicValidator:
         """
         self.strict = strict
         self.issues = []
-        self._valid_reference_pattern = re.compile(r"^[A-Z]+[0-9]*$")
+        self._valid_reference_pattern = re.compile(r"^(#[A-Z]+[0-9]+|[A-Z]+[0-9]*)$")
         self._valid_lib_id_pattern = re.compile(r"^[^:]+:[^:]+$")
 
     def validate_schematic_data(self, schematic_data: Dict[str, Any]) -> List[ValidationIssue]:
@@ -133,7 +133,7 @@ class SchematicValidator:
         Validate component reference format.
 
         Args:
-            reference: Reference to validate (e.g., "R1", "U5")
+            reference: Reference to validate (e.g., "R1", "U5", "#PWR01")
 
         Returns:
             True if reference is valid
@@ -231,7 +231,7 @@ class SchematicValidator:
                     message=f"{context}: Invalid reference format: {reference}",
                     level=ValidationLevel.ERROR,
                     context={"reference": reference},
-                    suggestion="Reference should match pattern: [A-Z]+[0-9]*",
+                    suggestion="Reference should match pattern: [A-Z]+[0-9]* or #[A-Z]+[0-9]* (for power symbols)",
                 )
             )
 

{kicad_sch_api-0.0.1.dist-info → kicad_sch_api-0.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kicad-sch-api
-Version: 0.0.1
+Version: 0.0.2
 Summary: Professional KiCAD schematic manipulation library with exact format preservation and AI agent integration
 Author-email: Circuit-Synth <info@circuit-synth.com>
 Maintainer-email: Circuit-Synth <info@circuit-synth.com>
@@ -10,7 +10,7 @@ Project-URL: Documentation, https://circuit-synth.github.io/kicad-sch-api/
 Project-URL: Repository, https://github.com/circuit-synth/kicad-sch-api.git
 Project-URL: Bug Reports, https://github.com/circuit-synth/kicad-sch-api/issues
 Project-URL: Changelog, https://github.com/circuit-synth/kicad-sch-api/blob/main/CHANGELOG.md
-Keywords: kicad,schematic,eda,electronics,circuit-design,ai,mcp,automation,pcb
+Keywords: kicad,schematic,eda,electronics,circuit-design,ai,automation,pcb
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -28,8 +28,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: sexpdata>=0.0.3
 Requires-Dist: typing-extensions>=4.0.0; python_version < "3.11"
-Provides-Extra: mcp
-Requires-Dist: mcp>=0.1.0; extra == "mcp"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
@@ -49,13 +47,11 @@ Dynamic: license-file
 
 **Professional KiCAD Schematic Manipulation Library with AI Agent Integration**
 
-A modern, high-performance Python library for programmatic manipulation of KiCAD schematic files (.kicad_sch) with exact format preservation, enhanced component management, and native AI agent support via Model Context Protocol (MCP).
 
 ## 🚀 Key Features
 
 - **📋 Exact Format Preservation**: Output matches KiCAD's native formatting exactly
 - **⚡ High Performance**: Optimized for large schematics with symbol caching
-- **🤖 AI Agent Integration**: Native MCP server for seamless AI agent interaction
 - **🔧 Enhanced API**: Intuitive object-oriented interface with bulk operations
 - **📚 Advanced Library Management**: Multi-source symbol lookup and caching
 - **✅ Professional Validation**: Comprehensive error collection and reporting
@@ -68,7 +64,6 @@ A modern, high-performance Python library for programmatic manipulation of KiCAD
 | **Schematic Support** | ✅ Full | ✅ Full | ❌ PCB Only |
 | **Format Preservation** | ✅ Exact | ❌ Basic | N/A |
 | **Performance** | ✅ Optimized | ⚠️ Basic | N/A |
-| **AI Integration** | ✅ Native MCP | ❌ None | ❌ None |
 | **Library Management** | ✅ Advanced | ⚠️ Basic | N/A |
 | **Runtime Dependencies** | ❌ None | ❌ None | ✅ KiCAD Required |
 
@@ -83,8 +78,6 @@ git clone https://github.com/circuit-synth/kicad-sch-api.git
 cd kicad-sch-api/python
 pip install -e .
 
-# For AI agent integration (MCP server)
-cd ../mcp-server
 npm install
 npm run build
 ```
@@ -141,15 +134,12 @@ stats = sch.get_performance_stats()
 print(f"Cache hit rate: {stats['symbol_cache']['hit_rate_percent']}%")
 ```
 
-### AI Agent Integration (MCP)
 
-Configure in Claude Desktop or compatible MCP client:
 
 ```json
 {
   "kicad-sch": {
     "command": "node",
-    "args": ["/path/to/kicad-sch-api/mcp-server/dist/index.js"],
     "env": {
       "PYTHON_PATH": "python3",
       "KICAD_SCH_API_PATH": "/path/to/kicad-sch-api/python"
@@ -165,7 +155,6 @@ User: "Create a voltage divider circuit with two 10k resistors"
 
 Claude: I'll create a voltage divider circuit for you.
 
-[Agent automatically uses MCP tools to:]
 1. Create new schematic
 2. Add R1 (10k resistor) at (100, 100)
 3. Add R2 (10k resistor) at (100, 150) 
@@ -187,8 +176,6 @@ The library consists of two main components:
 - **Symbol Caching**: High-performance library symbol management
 - **Comprehensive Validation**: Error collection and professional reporting
 
-### MCP Server (AI Integration)
-- **TypeScript MCP Server**: Implements Anthropic's MCP specification
 - **Python Bridge**: Reliable subprocess communication
 - **Comprehensive Tools**: 15+ tools for complete schematic manipulation
 - **Professional Error Handling**: Detailed error context for AI agents
@@ -200,8 +187,6 @@ The library consists of two main components:
 cd python
 python -m pytest tests/ -v --cov=kicad_sch_api
 
-# MCP server tests  
-cd mcp-server
 npm test
 
 # Format preservation tests

kicad_sch_api-0.0.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+kicad_sch_api/__init__.py,sha256=mogTeOic6O-WWOfpoRuBzPicVNha-gbdMrhJX4ir5PY,2821
+kicad_sch_api/py.typed,sha256=e4ldqxwpY7pNDG1olbvj4HSKr8sZ9vxgA_2ek8xXn-Q,70
+kicad_sch_api/core/__init__.py,sha256=ur_KeYBlGKl-e1hLpLdxAhGV2A-PCCGkcqd0r6KSeBA,566
+kicad_sch_api/core/components.py,sha256=P_-qZPNpA8LAT0M3dLHFF6XSFyNAnSlcKjUf6aREdUo,22425
+kicad_sch_api/core/formatter.py,sha256=MVF3Hhc5ZVPyVDYnGcxb88q0x0UTr2DQa45gppiFqNk,11953
+kicad_sch_api/core/parser.py,sha256=Ao1j8JPWHGBkznUi9k-RO4_sLcCrkE_5ialSxZAd0cQ,17943
+kicad_sch_api/core/schematic.py,sha256=O76nZvj4qffHkFrMJV5Z35xU95efPW-_mtAD8Nni7ao,15553
+kicad_sch_api/core/types.py,sha256=VyzloTl4RbjMKj0TKu5rEZ-rtxtiT8nvQw8L6xawEvs,9980
+kicad_sch_api/library/__init__.py,sha256=NG9UTdcpn25Bl9tPsYs9ED7bvpaVPVdtLMbnxkQkOnU,250
+kicad_sch_api/library/cache.py,sha256=_JtzEGgO7ViIKF4W2zVrvmHQBIiosp9hOr9pG06Tw6I,18917
+kicad_sch_api/utils/__init__.py,sha256=1V_yGgI7jro6MUc4Pviux_WIeJ1wmiYFID186SZwWLQ,277
+kicad_sch_api/utils/validation.py,sha256=7QZBtPHKu24SA6Bhkj7M-rxs76AVQZWhISDfsJYfV_0,15620
+kicad_sch_api-0.0.2.dist-info/licenses/LICENSE,sha256=Em65Nvte1G9MHc0rHqtYuGkCPcshD588itTa358J6gs,1070
+kicad_sch_api-0.0.2.dist-info/METADATA,sha256=0wa5C_1GHCirtAdlUTh2Eqqa1AreZkeTts6WkQaNjd8,6810
+kicad_sch_api-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kicad_sch_api-0.0.2.dist-info/entry_points.txt,sha256=VWKsFi2Jv7G_tmio3cNVhhIBfv_OZFaKa-T_ED84lc8,57
+kicad_sch_api-0.0.2.dist-info/top_level.txt,sha256=n0ex4gOJ1b_fARowcGqRzyOGZcHRhc5LZa6_vVgGxcI,14
+kicad_sch_api-0.0.2.dist-info/RECORD,,

kicad_sch_api/mcp/__init__.py

@@ -1,5 +0,0 @@
-"""MCP (Model Context Protocol) integration for kicad-sch-api."""
-
-from .server import MCPInterface
-
-__all__ = ["MCPInterface"]

kicad_sch_api/mcp/server.py

@@ -1,500 +0,0 @@
-#!/usr/bin/env python3
-"""
-Python MCP interface for kicad-sch-api.
-
-This script provides the Python side of the MCP bridge, handling commands
-from the TypeScript MCP server and executing them using kicad-sch-api.
-"""
-
-import json
-import logging
-import sys
-import traceback
-from typing import Any, Dict, Optional
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
-    handlers=[logging.StreamHandler(sys.stderr)],
-)
-
-logger = logging.getLogger("kicad_sch_api.mcp")
-
-# Import kicad-sch-api components
-try:
-    from ..core.components import Component
-    from ..core.schematic import Schematic
-    from ..library.cache import get_symbol_cache
-    from ..utils.validation import ValidationError, ValidationIssue
-except ImportError as e:
-    logger.error(f"Failed to import kicad-sch-api modules: {e}")
-    sys.exit(1)
-
-
-class MCPInterface:
-    """MCP command interface for kicad-sch-api."""
-
-    def __init__(self):
-        """Initialize the MCP interface."""
-        self.current_schematic: Optional[Schematic] = None
-        self.symbol_cache = get_symbol_cache()
-
-        # Command handlers
-        self.handlers = {
-            "ping": self.ping,
-            "load_schematic": self.load_schematic,
-            "save_schematic": self.save_schematic,
-            "create_schematic": self.create_schematic,
-            "add_component": self.add_component,
-            "update_component": self.update_component,
-            "remove_component": self.remove_component,
-            "get_component": self.get_component,
-            "find_components": self.find_components,
-            "add_wire": self.add_wire,
-            "connect_components": self.connect_components,
-            "bulk_update_components": self.bulk_update_components,
-            "validate_schematic": self.validate_schematic,
-            "get_schematic_summary": self.get_schematic_summary,
-            "search_library_symbols": self.search_library_symbols,
-            "add_library_path": self.add_library_path,
-        }
-
-        logger.info("MCP interface initialized")
-
-    def ping(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Health check command."""
-        return {
-            "success": True,
-            "message": "kicad-sch-api MCP interface is ready",
-            "version": "0.0.1",
-        }
-
-    def load_schematic(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Load a schematic file."""
-        try:
-            file_path = params.get("file_path")
-            if not file_path:
-                return {"success": False, "error": "file_path parameter required"}
-
-            self.current_schematic = Schematic.load(file_path)
-            summary = self.current_schematic.get_summary()
-
-            return {
-                "success": True,
-                "message": f"Loaded schematic: {file_path}",
-                "summary": summary,
-            }
-        except Exception as e:
-            logger.error(f"Error loading schematic: {e}")
-            return {"success": False, "error": str(e)}
-
-    def save_schematic(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Save the current schematic."""
-        try:
-            if not self.current_schematic:
-                return {"success": False, "error": "No schematic loaded"}
-
-            file_path = params.get("file_path")
-            preserve_format = params.get("preserve_format", True)
-
-            self.current_schematic.save(file_path, preserve_format)
-
-            return {
-                "success": True,
-                "message": f"Saved schematic to: {self.current_schematic.file_path}",
-            }
-        except Exception as e:
-            logger.error(f"Error saving schematic: {e}")
-            return {"success": False, "error": str(e)}
-
-    def create_schematic(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Create a new schematic."""
-        try:
-            name = params.get("name", "New Circuit")
-            self.current_schematic = Schematic.create(name)
-
-            return {
-                "success": True,
-                "message": f"Created new schematic: {name}",
-                "summary": self.current_schematic.get_summary(),
-            }
-        except Exception as e:
-            logger.error(f"Error creating schematic: {e}")
-            return {"success": False, "error": str(e)}
-
-    def add_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Add a component to the schematic."""
-        try:
-            if not self.current_schematic:
-                return {"success": False, "error": "No schematic loaded"}
-
-            lib_id = params.get("lib_id")
-            if not lib_id:
-                return {"success": False, "error": "lib_id parameter required"}
-
-            # Extract parameters
-            reference = params.get("reference")
-            value = params.get("value", "")
-            position = params.get("position")
-            footprint = params.get("footprint")
-            properties = params.get("properties", {})
-
-            # Convert position if provided
-            pos_tuple = None
-            if position:
-                pos_tuple = (position["x"], position["y"])
-
-            # Add component
-            component = self.current_schematic.components.add(
-                lib_id=lib_id,
-                reference=reference,
-                value=value,
-                position=pos_tuple,
-                footprint=footprint,
-                **properties,
-            )
-
-            return {
-                "success": True,
-                "message": f"Added component: {component.reference}",
-                "component": component.to_dict(),
-            }
-        except Exception as e:
-            logger.error(f"Error adding component: {e}")
-            return {"success": False, "error": str(e)}
-
-    def update_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Update a component's properties."""
-        try:
-            if not self.current_schematic:
-                return {"success": False, "error": "No schematic loaded"}
-
-            reference = params.get("reference")
-            if not reference:
-                return {"success": False, "error": "reference parameter required"}
-
-            component = self.current_schematic.components.get(reference)
-            if not component:
-                return {"success": False, "error": f"Component not found: {reference}"}
-
-            # Apply updates
-            updates = 0
-            if "value" in params:
-                component.value = params["value"]
-                updates += 1
-
-            if "position" in params:
-                pos = params["position"]
-                component.position = (pos["x"], pos["y"])
-                updates += 1
-
-            if "footprint" in params:
-                component.footprint = params["footprint"]
-                updates += 1
-
-            if "properties" in params:
-                for name, value in params["properties"].items():
-                    component.set_property(name, value)
-                    updates += 1
-
-            return {
-                "success": True,
-                "message": f"Updated component {reference} ({updates} changes)",
-                "component": component.to_dict(),
-            }
-        except Exception as e:
-            logger.error(f"Error updating component: {e}")
-            return {"success": False, "error": str(e)}
-
-    def remove_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Remove a component from the schematic."""
-        try:
-            if not self.current_schematic:
-                return {"success": False, "error": "No schematic loaded"}
-
-            reference = params.get("reference")
-            if not reference:
-                return {"success": False, "error": "reference parameter required"}
-
-            success = self.current_schematic.components.remove(reference)
-
-            if success:
-                return {"success": True, "message": f"Removed component: {reference}"}
-            else:
-                return {"success": False, "error": f"Component not found: {reference}"}
-        except Exception as e:
-            logger.error(f"Error removing component: {e}")
-            return {"success": False, "error": str(e)}
-
-    def get_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Get detailed information about a component."""
-        try:
-            if not self.current_schematic:
-                return {"success": False, "error": "No schematic loaded"}
-
-            reference = params.get("reference")
-            if not reference:
-                return {"success": False, "error": "reference parameter required"}
-
-            component = self.current_schematic.components.get(reference)
-            if not component:
-                return {"success": False, "error": f"Component not found: {reference}"}
-
-            return {"success": True, "component": component.to_dict()}
-        except Exception as e:
-            logger.error(f"Error getting component: {e}")
-            return {"success": False, "error": str(e)}
-
-    def find_components(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Find components by criteria."""
-        try:
-            if not self.current_schematic:
-                return {"success": False, "error": "No schematic loaded"}
-
-            # Filter out None values and convert to filter criteria
-            criteria = {k: v for k, v in params.items() if v is not None}
-
-            # Special handling for in_area
-            if "in_area" in criteria:
-                area = criteria["in_area"]
-                if len(area) == 4:
-                    criteria["in_area"] = tuple(area)
-
-            components = self.current_schematic.components.filter(**criteria)
-
-            return {
-                "success": True,
-                "count": len(components),
-                "components": [comp.to_dict() for comp in components],
-            }
-        except Exception as e:
-            logger.error(f"Error finding components: {e}")
-            return {"success": False, "error": str(e)}
-
-    def add_wire(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Add a wire connection."""
-        try:
-            if not self.current_schematic:
-                return {"success": False, "error": "No schematic loaded"}
-
-            start = params.get("start")
-            end = params.get("end")
-
-            if not start or not end:
-                return {"success": False, "error": "start and end parameters required"}
-
-            wire_uuid = self.current_schematic.add_wire(
-                (start["x"], start["y"]), (end["x"], end["y"])
-            )
-
-            return {
-                "success": True,
-                "message": f"Added wire from {start} to {end}",
-                "wire_uuid": wire_uuid,
-            }
-        except Exception as e:
-            logger.error(f"Error adding wire: {e}")
-            return {"success": False, "error": str(e)}
-
-    def connect_components(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Connect two component pins with a wire."""
-        try:
-            if not self.current_schematic:
-                return {"success": False, "error": "No schematic loaded"}
-
-            from_comp = params.get("from_component")
-            from_pin = params.get("from_pin")
-            to_comp = params.get("to_component")
-            to_pin = params.get("to_pin")
-
-            if not all([from_comp, from_pin, to_comp, to_pin]):
-                return {"success": False, "error": "All connection parameters required"}
-
-            # Get component pin positions
-            comp1 = self.current_schematic.components.get(from_comp)
-            comp2 = self.current_schematic.components.get(to_comp)
-
-            if not comp1:
-                return {"success": False, "error": f"Component not found: {from_comp}"}
-            if not comp2:
-                return {"success": False, "error": f"Component not found: {to_comp}"}
-
-            pin1_pos = comp1.get_pin_position(from_pin)
-            pin2_pos = comp2.get_pin_position(to_pin)
-
-            if not pin1_pos or not pin2_pos:
-                return {"success": False, "error": "Could not determine pin positions"}
-
-            # Add wire between pins
-            wire_uuid = self.current_schematic.add_wire(pin1_pos, pin2_pos)
-
-            return {
-                "success": True,
-                "message": f"Connected {from_comp}.{from_pin} to {to_comp}.{to_pin}",
-                "wire_uuid": wire_uuid,
-            }
-        except Exception as e:
-            logger.error(f"Error connecting components: {e}")
-            return {"success": False, "error": str(e)}
-
-    def bulk_update_components(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Update multiple components matching criteria."""
-        try:
-            if not self.current_schematic:
-                return {"success": False, "error": "No schematic loaded"}
-
-            criteria = params.get("criteria", {})
-            updates = params.get("updates", {})
-
-            if not criteria or not updates:
-                return {"success": False, "error": "criteria and updates parameters required"}
-
-            count = self.current_schematic.components.bulk_update(criteria, updates)
-
-            return {"success": True, "message": f"Updated {count} components", "count": count}
-        except Exception as e:
-            logger.error(f"Error in bulk update: {e}")
-            return {"success": False, "error": str(e)}
-
-    def validate_schematic(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Validate the current schematic."""
-        try:
-            if not self.current_schematic:
-                return {"success": False, "error": "No schematic loaded"}
-
-            issues = self.current_schematic.validate()
-
-            # Categorize issues
-            errors = [issue for issue in issues if issue.level.value in ("error", "critical")]
-            warnings = [issue for issue in issues if issue.level.value == "warning"]
-
-            return {
-                "success": True,
-                "valid": len(errors) == 0,
-                "issue_count": len(issues),
-                "errors": [str(issue) for issue in errors],
-                "warnings": [str(issue) for issue in warnings],
-            }
-        except Exception as e:
-            logger.error(f"Error validating schematic: {e}")
-            return {"success": False, "error": str(e)}
-
-    def get_schematic_summary(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Get summary of current schematic."""
-        try:
-            if not self.current_schematic:
-                return {"success": False, "error": "No schematic loaded"}
-
-            summary = self.current_schematic.get_summary()
-
-            return {"success": True, "summary": summary}
-        except Exception as e:
-            logger.error(f"Error getting summary: {e}")
-            return {"success": False, "error": str(e)}
-
-    def search_library_symbols(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Search for symbols in libraries."""
-        try:
-            query = params.get("query")
-            if not query:
-                return {"success": False, "error": "query parameter required"}
-
-            library = params.get("library")
-            limit = params.get("limit", 20)
-
-            symbols = self.symbol_cache.search_symbols(query, library, limit)
-
-            symbol_results = []
-            for symbol in symbols:
-                symbol_results.append(
-                    {
-                        "lib_id": symbol.lib_id,
-                        "name": symbol.name,
-                        "library": symbol.library,
-                        "description": symbol.description,
-                        "reference_prefix": symbol.reference_prefix,
-                        "pin_count": len(symbol.pins),
-                    }
-                )
-
-            return {"success": True, "count": len(symbol_results), "symbols": symbol_results}
-        except Exception as e:
-            logger.error(f"Error searching symbols: {e}")
-            return {"success": False, "error": str(e)}
-
-    def add_library_path(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Add a custom library path."""
-        try:
-            library_path = params.get("library_path")
-            if not library_path:
-                return {"success": False, "error": "library_path parameter required"}
-
-            success = self.symbol_cache.add_library_path(library_path)
-
-            if success:
-                return {"success": True, "message": f"Added library: {library_path}"}
-            else:
-                return {"success": False, "error": f"Failed to add library: {library_path}"}
-        except Exception as e:
-            logger.error(f"Error adding library: {e}")
-            return {"success": False, "error": str(e)}
-
-    def process_commands(self):
-        """Main command processing loop."""
-        logger.info("Starting command processing loop")
-
-        try:
-            for line in sys.stdin:
-                try:
-                    # Parse command
-                    request = json.loads(line.strip())
-                    command = request.get("command")
-                    params = request.get("params", {})
-                    request_id = request.get("id")
-
-                    # Execute command
-                    if command in self.handlers:
-                        result = self.handlers[command](params)
-                    else:
-                        result = {"success": False, "error": f"Unknown command: {command}"}
-
-                    # Send response
-                    response = {"id": request_id, "result": result}
-
-                    print(json.dumps(response))
-                    sys.stdout.flush()
-
-                except json.JSONDecodeError as e:
-                    logger.error(f"Invalid JSON input: {e}")
-                    error_response = {"id": None, "error": f"Invalid JSON: {e}"}
-                    print(json.dumps(error_response))
-                    sys.stdout.flush()
-
-                except Exception as e:
-                    logger.error(f"Error processing command: {e}")
-                    logger.debug(traceback.format_exc())
-                    error_response = {
-                        "id": request.get("id") if "request" in locals() else None,
-                        "error": str(e),
-                    }
-                    print(json.dumps(error_response))
-                    sys.stdout.flush()
-
-        except KeyboardInterrupt:
-            logger.info("Received interrupt signal")
-        except Exception as e:
-            logger.error(f"Fatal error in command processing: {e}")
-            logger.debug(traceback.format_exc())
-        finally:
-            logger.info("Command processing stopped")
-
-
-def main():
-    """Main entry point."""
-    interface = MCPInterface()
-    interface.process_commands()
-
-
-if __name__ == "__main__":
-    main()

kicad_sch_api-0.0.1.dist-info/RECORD

@@ -1,20 +0,0 @@
-kicad_sch_api/__init__.py,sha256=kvc92hzeQ6mSe3AsXSbK-CvGgoXtljyUCrzJcmBa-ao,2821
-kicad_sch_api/py.typed,sha256=e4ldqxwpY7pNDG1olbvj4HSKr8sZ9vxgA_2ek8xXn-Q,70
-kicad_sch_api/core/__init__.py,sha256=ur_KeYBlGKl-e1hLpLdxAhGV2A-PCCGkcqd0r6KSeBA,566
-kicad_sch_api/core/components.py,sha256=_sw8Hh2eemGHzYcjGoFrBeufX05G1JfO5inYMQDQD9k,22100
-kicad_sch_api/core/formatter.py,sha256=MVF3Hhc5ZVPyVDYnGcxb88q0x0UTr2DQa45gppiFqNk,11953
-kicad_sch_api/core/parser.py,sha256=x7aMqnsDO4Y2VJtYvgrrJJVi2r8SAFUjSCVtMIDVWDY,16652
-kicad_sch_api/core/schematic.py,sha256=O76nZvj4qffHkFrMJV5Z35xU95efPW-_mtAD8Nni7ao,15553
-kicad_sch_api/core/types.py,sha256=VyzloTl4RbjMKj0TKu5rEZ-rtxtiT8nvQw8L6xawEvs,9980
-kicad_sch_api/library/__init__.py,sha256=NG9UTdcpn25Bl9tPsYs9ED7bvpaVPVdtLMbnxkQkOnU,250
-kicad_sch_api/library/cache.py,sha256=_JtzEGgO7ViIKF4W2zVrvmHQBIiosp9hOr9pG06Tw6I,18917
-kicad_sch_api/mcp/__init__.py,sha256=dVit9lqiieujSYkyvfycE8JTo0AEWMI4plNxCK9pSD0,128
-kicad_sch_api/mcp/server.py,sha256=wGTdXPF6mMA8JoP-HiDUg7XJ21Dfr0ZoThB3WqKM_fQ,19079
-kicad_sch_api/utils/__init__.py,sha256=1V_yGgI7jro6MUc4Pviux_WIeJ1wmiYFID186SZwWLQ,277
-kicad_sch_api/utils/validation.py,sha256=i7VvhMaYxrb8wxddf0S3vvpDE7r8ldM53CDqF9-ARqI,15557
-kicad_sch_api-0.0.1.dist-info/licenses/LICENSE,sha256=Em65Nvte1G9MHc0rHqtYuGkCPcshD588itTa358J6gs,1070
-kicad_sch_api-0.0.1.dist-info/METADATA,sha256=jrEKEblgqF95O2aXEdzpuZhGm1gFp4RFFe3DKU86GeQ,7643
-kicad_sch_api-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kicad_sch_api-0.0.1.dist-info/entry_points.txt,sha256=VWKsFi2Jv7G_tmio3cNVhhIBfv_OZFaKa-T_ED84lc8,57
-kicad_sch_api-0.0.1.dist-info/top_level.txt,sha256=n0ex4gOJ1b_fARowcGqRzyOGZcHRhc5LZa6_vVgGxcI,14
-kicad_sch_api-0.0.1.dist-info/RECORD,,