88226d567b
New MCP tool `export_ipc2581` wrapping `kicad-cli pcb export ipc2581`: precision, compression, standard version, units, and the five --bom-col-* field mappings (internal id, mfg P/N, mfg, distributor P/N, distributor) that control the BOM part data embedded in the IPC-2581 file — directly useful for MES/assembly imports that need a real internal P/N rather than the description. Self-contained interface handler reading the saved .kicad_pcb. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
7161 lines
300 KiB
Python
7161 lines
300 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
KiCAD Python Interface Script for Model Context Protocol
|
|
|
|
This script handles communication between the MCP TypeScript server
|
|
and KiCAD's Python API (pcbnew). It receives commands via stdin as
|
|
JSON and returns responses via stdout also as JSON.
|
|
"""
|
|
|
|
import hashlib
|
|
import json
|
|
import logging
|
|
import os
|
|
import shutil
|
|
import sys
|
|
import traceback
|
|
from datetime import datetime
|
|
from logging.handlers import RotatingFileHandler
|
|
from pathlib import Path
|
|
from typing import Any, Dict, List, Optional, Tuple
|
|
|
|
# Fix cairo DLL loading on Windows before any cairocffi import.
|
|
# cairocffi uses cffi's ffi.dlopen('cairo-2') which needs the DLL on PATH.
|
|
if sys.platform == "win32":
|
|
for _bin_dir in [
|
|
os.environ.get("PYTHONPATH", ""),
|
|
os.path.dirname(sys.executable),
|
|
r"C:\Program Files\KiCad\9.0\bin",
|
|
r"C:\Program Files\KiCad\8.0\bin",
|
|
]:
|
|
if _bin_dir and os.path.isfile(os.path.join(_bin_dir, "cairo-2.dll")):
|
|
_current_path = os.environ.get("PATH", "")
|
|
if _bin_dir not in _current_path:
|
|
os.environ["PATH"] = _bin_dir + os.pathsep + _current_path
|
|
break
|
|
|
|
import sexpdata
|
|
from annotations import AnnotationLoader
|
|
from commands.wire_manager import WireManager
|
|
from resources.resource_definitions import RESOURCE_DEFINITIONS, handle_resource_read
|
|
|
|
# Import tool schemas, resource definitions, and IPC API annotations
|
|
from schemas.tool_schemas import TOOL_SCHEMAS
|
|
|
|
_annotation_loader = AnnotationLoader()
|
|
|
|
|
|
def _parse_log_level() -> int:
|
|
"""Return the configured Python log level from the MCP environment.
|
|
|
|
Honors KICAD_MCP_LOG_LEVEL (preferred) or LOG_LEVEL; defaults to INFO.
|
|
Accepts common aliases (WARN, FATAL) and an OFF/NONE/0 kill switch.
|
|
"""
|
|
raw_level = os.environ.get("KICAD_MCP_LOG_LEVEL") or os.environ.get("LOG_LEVEL") or "INFO"
|
|
normalized = raw_level.strip().upper()
|
|
aliases = {
|
|
"WARN": "WARNING",
|
|
"FATAL": "CRITICAL",
|
|
"OFF": "OFF",
|
|
"NONE": "OFF",
|
|
"FALSE": "OFF",
|
|
"0": "OFF",
|
|
}
|
|
normalized = aliases.get(normalized, normalized)
|
|
if normalized == "OFF":
|
|
return logging.CRITICAL + 1
|
|
return {
|
|
"CRITICAL": logging.CRITICAL,
|
|
"ERROR": logging.ERROR,
|
|
"WARNING": logging.WARNING,
|
|
"INFO": logging.INFO,
|
|
"DEBUG": logging.DEBUG,
|
|
}.get(normalized, logging.INFO)
|
|
|
|
|
|
def _parse_positive_int_env(name: str, default: int) -> int:
|
|
"""Return a non-negative int from env var ``name``, or ``default``."""
|
|
try:
|
|
value = int(os.environ.get(name, str(default)))
|
|
except ValueError:
|
|
return default
|
|
return value if value >= 0 else default
|
|
|
|
|
|
def _env_flag_enabled(name: str) -> bool:
|
|
"""Return True when env var ``name`` is a truthy flag (1/true/yes/on)."""
|
|
return os.environ.get(name, "").strip().lower() in {"1", "true", "yes", "on"}
|
|
|
|
|
|
_LOG_LEVEL = _parse_log_level()
|
|
|
|
# Configure logging.
|
|
# The file handler rotates (default 10 MB x 3 backups) so the log can never
|
|
# grow without bound (issue #181); the level honors the environment instead of
|
|
# being hardcoded to DEBUG. If ~/.kicad-mcp/logs isn't writable (sandboxed test
|
|
# envs, restricted CI runners) we fall back to console-only logging so importing
|
|
# this module never crashes.
|
|
try:
|
|
log_dir = os.path.join(os.path.expanduser("~"), ".kicad-mcp", "logs")
|
|
os.makedirs(log_dir, exist_ok=True)
|
|
log_file = os.path.join(log_dir, "kicad_interface.log")
|
|
max_log_bytes = _parse_positive_int_env("KICAD_MCP_LOG_MAX_BYTES", 10 * 1024 * 1024)
|
|
backup_count = _parse_positive_int_env("KICAD_MCP_LOG_BACKUP_COUNT", 3)
|
|
if max_log_bytes:
|
|
log_handler: logging.Handler = RotatingFileHandler(
|
|
log_file,
|
|
maxBytes=max_log_bytes,
|
|
backupCount=backup_count,
|
|
encoding="utf-8",
|
|
)
|
|
else:
|
|
log_handler = logging.FileHandler(log_file, encoding="utf-8")
|
|
logging.basicConfig(
|
|
level=_LOG_LEVEL,
|
|
format="%(asctime)s [%(levelname)s] %(message)s",
|
|
handlers=[log_handler],
|
|
force=True,
|
|
)
|
|
except (OSError, PermissionError):
|
|
logging.basicConfig(
|
|
level=_LOG_LEVEL,
|
|
format="%(asctime)s [%(levelname)s] %(message)s",
|
|
force=True,
|
|
)
|
|
logger = logging.getLogger("kicad_interface")
|
|
|
|
# kicad-skip's S-expression parser emits per-node DEBUG logs that can fill disks
|
|
# during hierarchy traversal (issue #181). Keep those quiet unless explicitly
|
|
# enabled via KICAD_MCP_DEBUG_SKIP.
|
|
_SKIP_LOG_LEVEL = logging.DEBUG if _env_flag_enabled("KICAD_MCP_DEBUG_SKIP") else logging.WARNING
|
|
for _skip_logger_name in ("skip", "skip.sexp", "skip.sexp.parser", "skip.sexp.sourcefile"):
|
|
logging.getLogger(_skip_logger_name).setLevel(_SKIP_LOG_LEVEL)
|
|
|
|
# Log Python environment details
|
|
logger.info(f"Python version: {sys.version}")
|
|
logger.info(f"Python executable: {sys.executable}")
|
|
logger.info(f"Platform: {sys.platform}")
|
|
logger.info(f"Working directory: {os.getcwd()}")
|
|
|
|
# Windows-specific diagnostics
|
|
if sys.platform == "win32":
|
|
logger.info("=== Windows Environment Diagnostics ===")
|
|
logger.info(f"PYTHONPATH: {os.environ.get('PYTHONPATH', 'NOT SET')}")
|
|
logger.info(f"PATH: {os.environ.get('PATH', 'NOT SET')[:200]}...") # Truncate PATH
|
|
|
|
# Check for common KiCAD installations
|
|
common_kicad_paths = [r"C:\Program Files\KiCad", r"C:\Program Files (x86)\KiCad"]
|
|
|
|
found_kicad = False
|
|
for base_path in common_kicad_paths:
|
|
if os.path.exists(base_path):
|
|
logger.info(f"Found KiCAD installation at: {base_path}")
|
|
# List versions
|
|
try:
|
|
versions = [
|
|
d for d in os.listdir(base_path) if os.path.isdir(os.path.join(base_path, d))
|
|
]
|
|
logger.info(f" Versions found: {', '.join(versions)}")
|
|
for version in versions:
|
|
python_path = os.path.join(
|
|
base_path, version, "lib", "python3", "dist-packages"
|
|
)
|
|
if os.path.exists(python_path):
|
|
logger.info(f" ✓ Python path exists: {python_path}")
|
|
found_kicad = True
|
|
else:
|
|
logger.warning(f" ✗ Python path missing: {python_path}")
|
|
except Exception as e:
|
|
logger.warning(f" Could not list versions: {e}")
|
|
|
|
if not found_kicad:
|
|
logger.warning("No KiCAD installations found in standard locations!")
|
|
logger.warning(
|
|
"Please ensure KiCAD 9.0+ is installed from https://www.kicad.org/download/windows/"
|
|
)
|
|
|
|
logger.info("========================================")
|
|
|
|
# Add utils directory to path for imports
|
|
utils_dir = os.path.join(os.path.dirname(__file__))
|
|
if utils_dir not in sys.path:
|
|
sys.path.insert(0, utils_dir)
|
|
|
|
from utils.kicad_process import KiCADProcessManager, check_and_launch_kicad
|
|
|
|
# Import platform helper and add KiCAD paths
|
|
from utils.platform_helper import PlatformHelper
|
|
|
|
logger.info(f"Detecting KiCAD Python paths for {PlatformHelper.get_platform_name()}...")
|
|
paths_added = PlatformHelper.add_kicad_to_python_path()
|
|
|
|
if paths_added:
|
|
logger.info("Successfully added KiCAD Python paths to sys.path")
|
|
else:
|
|
logger.warning("No KiCAD Python paths found - attempting to import pcbnew from system path")
|
|
|
|
logger.info(f"Current Python path: {sys.path}")
|
|
|
|
# Check if auto-launch is enabled
|
|
AUTO_LAUNCH_KICAD = os.environ.get("KICAD_AUTO_LAUNCH", "false").lower() == "true"
|
|
if AUTO_LAUNCH_KICAD:
|
|
logger.info("KiCAD auto-launch enabled")
|
|
|
|
# Check which backend to use
|
|
# KICAD_BACKEND can be: 'auto', 'ipc', or 'swig'
|
|
KICAD_BACKEND = os.environ.get("KICAD_BACKEND", "auto").lower()
|
|
logger.info(f"KiCAD backend preference: {KICAD_BACKEND}")
|
|
|
|
# Try to use IPC backend first if available and preferred
|
|
USE_IPC_BACKEND = False
|
|
ipc_backend = None
|
|
|
|
if KICAD_BACKEND in ("auto", "ipc"):
|
|
try:
|
|
logger.info("Checking IPC backend availability...")
|
|
from kicad_api.ipc_backend import IPCBackend
|
|
|
|
# Try to connect to running KiCAD
|
|
ipc_backend = IPCBackend()
|
|
if ipc_backend.connect():
|
|
USE_IPC_BACKEND = True
|
|
logger.info(f"✓ Using IPC backend - real-time UI sync enabled!")
|
|
logger.info(f" KiCAD version: {ipc_backend.get_version()}")
|
|
else:
|
|
logger.info("IPC backend available but KiCAD not running with IPC enabled")
|
|
ipc_backend = None
|
|
except ImportError:
|
|
logger.info("IPC backend not available (kicad-python not installed)")
|
|
except Exception as e:
|
|
logger.info(f"IPC backend connection failed: {e}")
|
|
ipc_backend = None
|
|
|
|
# Fall back to SWIG backend if IPC not available
|
|
if not USE_IPC_BACKEND and KICAD_BACKEND != "ipc":
|
|
# Import KiCAD's Python API (SWIG)
|
|
try:
|
|
logger.info("Attempting to import pcbnew module (SWIG backend)...")
|
|
import pcbnew # type: ignore
|
|
|
|
logger.info(f"Successfully imported pcbnew module from: {pcbnew.__file__}")
|
|
# Deferred — GetBuildVersion() triggers 55-65 s wxApp init on macOS.
|
|
# The _warmup handler pays this cost during startup (not on first tool call).
|
|
logger.warning("Using SWIG backend - changes require manual reload in KiCAD UI")
|
|
except ImportError as e:
|
|
logger.error(f"Failed to import pcbnew module: {e}")
|
|
logger.error(f"Current sys.path: {sys.path}")
|
|
|
|
# Platform-specific help message
|
|
help_message = ""
|
|
if sys.platform == "win32":
|
|
help_message = """
|
|
Windows Troubleshooting:
|
|
1. Verify KiCAD is installed: C:\\Program Files\\KiCad\\9.0
|
|
2. Check PYTHONPATH environment variable points to:
|
|
C:\\Program Files\\KiCad\\9.0\\lib\\python3\\dist-packages
|
|
3. Test with: "C:\\Program Files\\KiCad\\9.0\\bin\\python.exe" -c "import pcbnew"
|
|
4. Log file location: %USERPROFILE%\\.kicad-mcp\\logs\\kicad_interface.log
|
|
5. Run setup-windows.ps1 for automatic configuration
|
|
"""
|
|
elif sys.platform == "darwin":
|
|
help_message = """
|
|
macOS Troubleshooting:
|
|
1. Verify KiCAD is installed: /Applications/KiCad/KiCad.app
|
|
2. Check PYTHONPATH points to KiCAD's Python packages
|
|
3. Run: python3 -c "import pcbnew" to test
|
|
"""
|
|
else: # Linux
|
|
help_message = """
|
|
Linux Troubleshooting:
|
|
1. Verify KiCAD is installed: apt list --installed | grep kicad
|
|
2. Check: /usr/lib/kicad/lib/python3/dist-packages exists
|
|
3. Test: python3 -c "import pcbnew"
|
|
"""
|
|
|
|
logger.error(help_message)
|
|
|
|
error_response = {
|
|
"success": False,
|
|
"message": "Failed to import pcbnew module - KiCAD Python API not found",
|
|
"errorDetails": f"Error: {str(e)}\n\n{help_message}\n\nPython sys.path:\n{chr(10).join(sys.path)}",
|
|
}
|
|
print(json.dumps(error_response))
|
|
sys.exit(1)
|
|
except Exception as e:
|
|
logger.error(f"Unexpected error importing pcbnew: {e}")
|
|
logger.error(traceback.format_exc())
|
|
error_response = {
|
|
"success": False,
|
|
"message": "Error importing pcbnew module",
|
|
"errorDetails": str(e),
|
|
}
|
|
print(json.dumps(error_response))
|
|
sys.exit(1)
|
|
|
|
# If IPC-only mode requested but not available, exit with error
|
|
elif KICAD_BACKEND == "ipc" and not USE_IPC_BACKEND:
|
|
error_response = {
|
|
"success": False,
|
|
"message": "IPC backend requested but not available",
|
|
"errorDetails": "KiCAD must be running with IPC API enabled. Enable at: Preferences > Plugins > Enable IPC API Server",
|
|
}
|
|
print(json.dumps(error_response))
|
|
sys.exit(1)
|
|
|
|
# Import command handlers
|
|
try:
|
|
logger.info("Importing command handlers...")
|
|
from commands.board import BoardCommands
|
|
from commands.component import ComponentCommands
|
|
from commands.component_schematic import ComponentManager
|
|
from commands.connection_schematic import ConnectionManager
|
|
from commands.datasheet_manager import DatasheetManager
|
|
from commands.design_rules import DesignRuleCommands
|
|
from commands.export import ExportCommands
|
|
from commands.footprint import FootprintCreator
|
|
from commands.freerouting import FreeroutingCommands
|
|
from commands.jlcpcb import JLCPCBClient, test_jlcpcb_connection
|
|
from commands.jlcpcb_parts import JLCPCBPartsManager
|
|
from commands.library import (
|
|
LibraryCommands,
|
|
)
|
|
from commands.library import LibraryManager as FootprintLibraryManager
|
|
from commands.library_schematic import LibraryManager as SchematicLibraryManager
|
|
from commands.library_symbol import SymbolLibraryCommands, SymbolLibraryManager
|
|
from commands.project import ProjectCommands
|
|
from commands.routing import RoutingCommands
|
|
from commands.schematic import SchematicManager
|
|
from commands.schematic_batch import SchematicBatchCommands
|
|
from commands.schematic_field_layout import SchematicFieldLayoutCommands
|
|
from commands.schematic_hierarchy import SchematicHierarchyCommands
|
|
from commands.symbol_creator import SymbolCreator
|
|
from commands.symbol_pins import SymbolPinCommands
|
|
|
|
logger.info("Successfully imported all command handlers")
|
|
except ImportError as e:
|
|
logger.error(f"Failed to import command handlers: {e}")
|
|
error_response = {
|
|
"success": False,
|
|
"message": "Failed to import command handlers",
|
|
"errorDetails": str(e),
|
|
}
|
|
print(json.dumps(error_response))
|
|
sys.exit(1)
|
|
|
|
|
|
def _svg_to_png(svg_path: str, width: int, height: int) -> Optional[bytes]:
|
|
"""Convert SVG to PNG. No cffi dependency.
|
|
|
|
Priority:
|
|
1. pymupdf (fitz) — bundled MuPDF renderer, pure Python, no system deps
|
|
2. Inkscape CLI — accurate KiCAD SVG rendering
|
|
3. ImageMagick convert — broad availability fallback
|
|
Returns PNG bytes or None if all converters fail.
|
|
"""
|
|
import subprocess
|
|
import tempfile
|
|
|
|
try:
|
|
import fitz
|
|
|
|
doc = fitz.open(svg_path)
|
|
page = doc[0]
|
|
mat = fitz.Matrix(width / page.rect.width, height / page.rect.height)
|
|
return page.get_pixmap(matrix=mat).tobytes("png")
|
|
except Exception:
|
|
pass
|
|
|
|
out_path = os.path.join(tempfile.mkdtemp(), "out.png")
|
|
|
|
try:
|
|
r = subprocess.run(
|
|
[
|
|
"inkscape",
|
|
svg_path,
|
|
"--export-type=png",
|
|
f"--export-width={width}",
|
|
f"--export-height={height}",
|
|
f"--export-filename={out_path}",
|
|
],
|
|
capture_output=True,
|
|
timeout=60,
|
|
)
|
|
if r.returncode == 0 and os.path.exists(out_path):
|
|
with open(out_path, "rb") as f:
|
|
return f.read()
|
|
except (FileNotFoundError, subprocess.TimeoutExpired):
|
|
pass
|
|
|
|
try:
|
|
r = subprocess.run(
|
|
["convert", "-density", "150", svg_path, "-resize", f"{width}x{height}", out_path],
|
|
capture_output=True,
|
|
timeout=60,
|
|
)
|
|
if r.returncode == 0 and os.path.exists(out_path):
|
|
with open(out_path, "rb") as f:
|
|
return f.read()
|
|
except (FileNotFoundError, subprocess.TimeoutExpired):
|
|
pass
|
|
|
|
return None
|
|
|
|
|
|
class KiCADInterface:
|
|
"""Main interface class to handle KiCAD operations"""
|
|
|
|
def __init__(self) -> None:
|
|
"""Initialize the interface and command handlers"""
|
|
self.board = None
|
|
self.project_filename = None
|
|
# On-disk signature (mtime_ns, sha256_hex) of self.board's file as of
|
|
# last load or successful auto-save. Used by _auto_save_board() to
|
|
# detect external modifications and refuse to clobber them.
|
|
self._board_disk_signature: Optional[Tuple[int, str]] = None
|
|
self._last_auto_save_status: Optional[Dict[str, Any]] = None
|
|
# Number of timestamped backups to keep in .mcp-backups/ per board file.
|
|
self._auto_save_backup_keep = 20
|
|
self.use_ipc = USE_IPC_BACKEND
|
|
self.ipc_backend = ipc_backend
|
|
self.ipc_board_api = None
|
|
|
|
if self.use_ipc:
|
|
logger.info("Initializing with IPC backend (real-time UI sync enabled)")
|
|
try:
|
|
self.ipc_board_api = self.ipc_backend.get_board()
|
|
logger.info("✓ Got IPC board API")
|
|
except Exception as e:
|
|
logger.warning(f"Could not get IPC board API: {e}")
|
|
else:
|
|
logger.info("Initializing with SWIG backend")
|
|
|
|
logger.info("Initializing command handlers...")
|
|
|
|
# Initialize footprint library manager
|
|
self.footprint_library = FootprintLibraryManager()
|
|
|
|
# Initialize command handlers
|
|
self.project_commands = ProjectCommands(self.board)
|
|
self.board_commands = BoardCommands(self.board)
|
|
self.component_commands = ComponentCommands(self.board, self.footprint_library)
|
|
self.routing_commands = RoutingCommands(self.board)
|
|
self.freerouting_commands = FreeroutingCommands(self.board)
|
|
self.design_rule_commands = DesignRuleCommands(self.board)
|
|
self.export_commands = ExportCommands(self.board)
|
|
self.library_commands = LibraryCommands(self.footprint_library)
|
|
self._current_project_path: Optional[Path] = None # set when boardPath is known
|
|
|
|
# Initialize symbol library manager (for searching local KiCad symbol libraries)
|
|
self.symbol_library_commands = SymbolLibraryCommands()
|
|
|
|
# Symbol pin discovery commands (read-only pin lookup from symbol libraries)
|
|
self.symbol_pin_commands = SymbolPinCommands()
|
|
# Schematic hierarchy commands (insert sheets, scaffold sub-sheets)
|
|
self.hierarchy_commands = SchematicHierarchyCommands(self)
|
|
# Schematic field placement / layout-check commands
|
|
self.field_layout_commands = SchematicFieldLayoutCommands()
|
|
# Batch schematic authoring commands (need an interface back-reference for the
|
|
# single-item add/edit/get handlers, footprint library, and sub-sheet fixer)
|
|
self.batch_commands = SchematicBatchCommands(self)
|
|
|
|
# Initialize JLCPCB API integration
|
|
self.jlcpcb_client = JLCPCBClient() # Official API (requires auth)
|
|
from commands.jlcsearch import JLCSearchClient
|
|
|
|
self.jlcsearch_client = JLCSearchClient() # Public API (no auth required)
|
|
self.jlcpcb_parts = JLCPCBPartsManager()
|
|
|
|
# Schematic-related classes don't need board reference
|
|
# as they operate directly on schematic files
|
|
|
|
# Command routing dictionary
|
|
self.command_routes = {
|
|
# Project commands
|
|
"create_project": self._handle_create_project,
|
|
"open_project": self._handle_open_project,
|
|
"save_project": self.project_commands.save_project,
|
|
"snapshot_project": self._handle_snapshot_project,
|
|
"get_project_info": self.project_commands.get_project_info,
|
|
# Board commands
|
|
"set_board_size": self.board_commands.set_board_size,
|
|
"add_layer": self.board_commands.add_layer,
|
|
"set_active_layer": self.board_commands.set_active_layer,
|
|
"get_board_info": self.board_commands.get_board_info,
|
|
"get_layer_list": self.board_commands.get_layer_list,
|
|
"get_board_2d_view": self.board_commands.get_board_2d_view,
|
|
"get_board_extents": self.board_commands.get_board_extents,
|
|
"add_board_outline": self.board_commands.add_board_outline,
|
|
"add_mounting_hole": self.board_commands.add_mounting_hole,
|
|
"add_text": self.board_commands.add_text,
|
|
"add_board_text": self.board_commands.add_text, # Alias for TypeScript tool
|
|
# Component commands
|
|
"route_pad_to_pad": self.routing_commands.route_pad_to_pad,
|
|
"place_component": self._handle_place_component,
|
|
"move_component": self.component_commands.move_component,
|
|
"rotate_component": self.component_commands.rotate_component,
|
|
"delete_component": self.component_commands.delete_component,
|
|
"edit_component": self.component_commands.edit_component,
|
|
"get_component_properties": self.component_commands.get_component_properties,
|
|
"get_component_list": self.component_commands.get_component_list,
|
|
"find_component": self.component_commands.find_component,
|
|
"get_component_pads": self.component_commands.get_component_pads,
|
|
"get_pad_position": self.component_commands.get_pad_position,
|
|
"place_component_array": self.component_commands.place_component_array,
|
|
"align_components": self.component_commands.align_components,
|
|
"check_courtyard_overlaps": self.component_commands.check_courtyard_overlaps,
|
|
"duplicate_component": self.component_commands.duplicate_component,
|
|
# Routing commands
|
|
"add_net": self.routing_commands.add_net,
|
|
"route_trace": self.routing_commands.route_trace,
|
|
"route_arc_trace": self.routing_commands.route_arc_trace,
|
|
"add_via": self.routing_commands.add_via,
|
|
"delete_trace": self.routing_commands.delete_trace,
|
|
"query_traces": self.routing_commands.query_traces,
|
|
"query_zones": self.routing_commands.query_zones,
|
|
"add_gnd_stitching_vias": self.routing_commands.add_gnd_stitching_vias,
|
|
"modify_trace": self.routing_commands.modify_trace,
|
|
"copy_routing_pattern": self.routing_commands.copy_routing_pattern,
|
|
"get_nets_list": self.routing_commands.get_nets_list,
|
|
"create_netclass": self.routing_commands.create_netclass,
|
|
"add_copper_pour": self.routing_commands.add_copper_pour,
|
|
"route_differential_pair": self.routing_commands.route_differential_pair,
|
|
"refill_zones": self._handle_refill_zones,
|
|
# Design rule commands
|
|
"set_design_rules": self.design_rule_commands.set_design_rules,
|
|
"get_design_rules": self.design_rule_commands.get_design_rules,
|
|
"run_drc": self.design_rule_commands.run_drc,
|
|
"get_drc_violations": self.design_rule_commands.get_drc_violations,
|
|
# Export commands
|
|
"export_gerber": self.export_commands.export_gerber,
|
|
"export_pdf": self.export_commands.export_pdf,
|
|
"export_svg": self.export_commands.export_svg,
|
|
"export_3d": self.export_commands.export_3d,
|
|
"export_bom": self.export_commands.export_bom,
|
|
# Library commands (footprint management)
|
|
"list_libraries": self.library_commands.list_libraries,
|
|
"search_footprints": self.library_commands.search_footprints,
|
|
"list_library_footprints": self.library_commands.list_library_footprints,
|
|
"get_footprint_info": self.library_commands.get_footprint_info,
|
|
# Symbol library commands (local KiCad symbol library search)
|
|
"list_symbol_libraries": self.symbol_library_commands.list_symbol_libraries,
|
|
"search_symbols": self.symbol_library_commands.search_symbols,
|
|
"list_library_symbols": self.symbol_library_commands.list_library_symbols,
|
|
"get_symbol_info": self.symbol_library_commands.get_symbol_info,
|
|
# Symbol pin discovery commands (read pins straight from symbol libraries)
|
|
"list_symbol_pins": self.symbol_pin_commands.list_symbol_pins,
|
|
"batch_list_symbol_pins": self.symbol_pin_commands.batch_list_symbol_pins,
|
|
# Schematic hierarchy commands (sheet insertion + subsheet scaffolding)
|
|
"add_hierarchical_sheet": self.hierarchy_commands.add_hierarchical_sheet,
|
|
"create_hierarchical_subsheet": self.hierarchy_commands.create_hierarchical_subsheet,
|
|
# Schematic field placement commands
|
|
"set_schematic_property_position": self.field_layout_commands.set_schematic_property_position,
|
|
"batch_set_schematic_property_positions": self.field_layout_commands.batch_set_schematic_property_positions,
|
|
"autoplace_schematic_fields": self.field_layout_commands.autoplace_schematic_fields,
|
|
# Batch schematic authoring commands
|
|
"batch_add_components": self.batch_commands.batch_add_components,
|
|
"batch_edit_schematic_components": self.batch_commands.batch_edit_schematic_components,
|
|
"replace_schematic_component": self.batch_commands.replace_schematic_component,
|
|
"batch_add_no_connects": self.batch_commands.batch_add_no_connects,
|
|
"batch_connect": self.batch_commands.batch_connect,
|
|
"batch_add_and_connect": self.batch_commands.batch_add_and_connect,
|
|
# JLCPCB API commands (complete parts catalog via API)
|
|
"download_jlcpcb_database": self._handle_download_jlcpcb_database,
|
|
"search_jlcpcb_parts": self._handle_search_jlcpcb_parts,
|
|
"get_jlcpcb_part": self._handle_get_jlcpcb_part,
|
|
"get_jlcpcb_database_stats": self._handle_get_jlcpcb_database_stats,
|
|
"suggest_jlcpcb_alternatives": self._handle_suggest_jlcpcb_alternatives,
|
|
# Datasheet commands
|
|
"enrich_datasheets": self._handle_enrich_datasheets,
|
|
"get_datasheet_url": self._handle_get_datasheet_url,
|
|
# Schematic commands
|
|
"create_schematic": self._handle_create_schematic,
|
|
"load_schematic": self._handle_load_schematic,
|
|
"add_schematic_component": self._handle_add_schematic_component,
|
|
"delete_schematic_component": self._handle_delete_schematic_component,
|
|
"edit_schematic_component": self._handle_edit_schematic_component,
|
|
"set_schematic_component_property": self._handle_set_schematic_component_property,
|
|
"remove_schematic_component_property": self._handle_remove_schematic_component_property,
|
|
"get_schematic_component": self._handle_get_schematic_component,
|
|
"add_schematic_wire": self._handle_add_schematic_wire,
|
|
"add_schematic_net_label": self._handle_add_schematic_net_label,
|
|
"add_no_connect": self._handle_add_no_connect,
|
|
"connect_to_net": self._handle_connect_to_net,
|
|
"connect_passthrough": self._handle_connect_passthrough,
|
|
"get_schematic_pin_locations": self._handle_get_schematic_pin_locations,
|
|
"get_net_connections": self._handle_get_net_connections,
|
|
"get_wire_connections": self._handle_get_wire_connections,
|
|
"get_net_at_point": self._handle_get_net_at_point,
|
|
"run_erc": self._handle_run_erc,
|
|
"export_netlist": self._handle_export_netlist,
|
|
"export_gerbers": self._handle_export_gerbers,
|
|
"export_drill": self._handle_export_drill,
|
|
"export_ipc2581": self._handle_export_ipc2581,
|
|
"generate_netlist": self._handle_generate_netlist,
|
|
"sync_schematic_to_board": self._handle_sync_schematic_to_board,
|
|
"list_schematic_libraries": self._handle_list_schematic_libraries,
|
|
"get_schematic_view": self._handle_get_schematic_view,
|
|
"list_schematic_components": self._handle_list_schematic_components,
|
|
"list_schematic_nets": self._handle_list_schematic_nets,
|
|
"list_schematic_wires": self._handle_list_schematic_wires,
|
|
"list_schematic_labels": self._handle_list_schematic_labels,
|
|
"move_schematic_component": self._handle_move_schematic_component,
|
|
"rotate_schematic_component": self._handle_rotate_schematic_component,
|
|
"annotate_schematic": self._handle_annotate_schematic,
|
|
"delete_schematic_wire": self._handle_delete_schematic_wire,
|
|
"delete_schematic_net_label": self._handle_delete_schematic_net_label,
|
|
"move_schematic_net_label": self._handle_move_schematic_net_label,
|
|
"export_schematic_pdf": self._handle_export_schematic_pdf,
|
|
"export_schematic_svg": self._handle_export_schematic_svg,
|
|
# Schematic analysis tools (read-only)
|
|
"get_schematic_view_region": self._handle_get_schematic_view_region,
|
|
"find_overlapping_elements": self._handle_find_overlapping_elements,
|
|
"get_elements_in_region": self._handle_get_elements_in_region,
|
|
"find_wires_crossing_symbols": self._handle_find_wires_crossing_symbols,
|
|
"find_orphaned_wires": self._handle_find_orphaned_wires,
|
|
"list_floating_labels": self._handle_list_floating_labels,
|
|
"snap_to_grid": self._handle_snap_to_grid,
|
|
"add_schematic_hierarchical_label": self._handle_add_schematic_hierarchical_label,
|
|
"add_schematic_text": self._handle_add_schematic_text,
|
|
"list_schematic_texts": self._handle_list_schematic_texts,
|
|
"add_sheet_pin": self._handle_add_sheet_pin,
|
|
"import_svg_logo": self._handle_import_svg_logo,
|
|
# UI/Process management commands
|
|
"get_backend_state": self._handle_get_backend_state,
|
|
"check_kicad_ui": self._handle_check_kicad_ui,
|
|
"launch_kicad_ui": self._handle_launch_kicad_ui,
|
|
# Internal warm-up (pays wxApp init cost during startup)
|
|
"_warmup": self._handle_warmup,
|
|
# IPC-specific commands (real-time operations)
|
|
"get_backend_info": self._handle_get_backend_info,
|
|
"ipc_add_track": self._handle_ipc_add_track,
|
|
"ipc_add_via": self._handle_ipc_add_via,
|
|
"ipc_add_text": self._handle_ipc_add_text,
|
|
"ipc_list_components": self._handle_ipc_list_components,
|
|
"ipc_get_tracks": self._handle_ipc_get_tracks,
|
|
"ipc_get_vias": self._handle_ipc_get_vias,
|
|
"ipc_save_board": self._handle_ipc_save_board,
|
|
# Footprint commands
|
|
"create_footprint": self._handle_create_footprint,
|
|
"edit_footprint_pad": self._handle_edit_footprint_pad,
|
|
"list_footprint_libraries": self._handle_list_footprint_libraries,
|
|
"register_footprint_library": self._handle_register_footprint_library,
|
|
# Symbol creator commands
|
|
"create_symbol": self._handle_create_symbol,
|
|
"delete_symbol": self._handle_delete_symbol,
|
|
"list_symbols_in_library": self._handle_list_symbols_in_library,
|
|
"register_symbol_library": self._handle_register_symbol_library,
|
|
# Freerouting autoroute commands
|
|
"autoroute": self.freerouting_commands.autoroute,
|
|
"export_dsn": self.freerouting_commands.export_dsn,
|
|
"import_ses": self.freerouting_commands.import_ses,
|
|
"check_freerouting": self.freerouting_commands.check_freerouting,
|
|
}
|
|
|
|
logger.info(f"KiCAD interface initialized (backend: {'IPC' if self.use_ipc else 'SWIG'})")
|
|
|
|
# Commands that can be handled via IPC for real-time updates
|
|
IPC_CAPABLE_COMMANDS = {
|
|
# Routing commands
|
|
"route_trace": "_ipc_route_trace",
|
|
"route_arc_trace": "_ipc_route_arc_trace",
|
|
"add_via": "_ipc_add_via",
|
|
"add_net": "_ipc_add_net",
|
|
"delete_trace": "_ipc_delete_trace",
|
|
"query_traces": "_ipc_query_traces",
|
|
"get_nets_list": "_ipc_get_nets_list",
|
|
# Zone commands
|
|
"add_copper_pour": "_ipc_add_copper_pour",
|
|
"refill_zones": "_ipc_refill_zones",
|
|
# Board commands
|
|
"add_text": "_ipc_add_text",
|
|
"add_board_text": "_ipc_add_text",
|
|
"set_board_size": "_ipc_set_board_size",
|
|
"get_board_info": "_ipc_get_board_info",
|
|
"add_board_outline": "_ipc_add_board_outline",
|
|
"add_mounting_hole": "_ipc_add_mounting_hole",
|
|
"get_layer_list": "_ipc_get_layer_list",
|
|
# Component commands
|
|
"place_component": "_ipc_place_component",
|
|
"move_component": "_ipc_move_component",
|
|
"rotate_component": "_ipc_rotate_component",
|
|
"delete_component": "_ipc_delete_component",
|
|
"get_component_list": "_ipc_get_component_list",
|
|
"get_component_properties": "_ipc_get_component_properties",
|
|
# Save command
|
|
"save_project": "_ipc_save_project",
|
|
}
|
|
|
|
# Commands that are implemented by the explicit IPC command handlers in
|
|
# command_routes, rather than by the generic IPC_CAPABLE_COMMANDS fast path.
|
|
IPC_DIRECT_COMMANDS = {
|
|
"ipc_add_track",
|
|
"ipc_add_via",
|
|
"ipc_add_text",
|
|
"ipc_list_components",
|
|
"ipc_get_tracks",
|
|
"ipc_get_vias",
|
|
"ipc_save_board",
|
|
}
|
|
|
|
def _refresh_ipc_board_api(self) -> bool:
|
|
"""Refresh the IPC board API after KiCAD or a board becomes available."""
|
|
ipc_backend = getattr(self, "ipc_backend", None)
|
|
if not ipc_backend or not ipc_backend.is_connected():
|
|
self.ipc_board_api = None
|
|
return False
|
|
|
|
try:
|
|
self.ipc_board_api = ipc_backend.get_board()
|
|
return True
|
|
except Exception as e:
|
|
logger.warning(f"Connected to KiCAD IPC, but no board API is available yet: {e}")
|
|
self.ipc_board_api = None
|
|
return False
|
|
|
|
def _try_enable_ipc_backend(self, force: bool = False) -> bool:
|
|
"""Try to switch an already-running interface to IPC when KiCAD is available."""
|
|
if KICAD_BACKEND == "swig":
|
|
return False
|
|
|
|
ipc_backend = getattr(self, "ipc_backend", None)
|
|
if self.use_ipc and ipc_backend and ipc_backend.is_connected():
|
|
self._refresh_ipc_board_api()
|
|
return True
|
|
|
|
if not force and not KiCADProcessManager.is_running():
|
|
return False
|
|
|
|
try:
|
|
from kicad_api.ipc_backend import IPCBackend
|
|
|
|
backend = ipc_backend or IPCBackend()
|
|
if not backend.is_connected():
|
|
backend.connect()
|
|
|
|
self.ipc_backend = backend
|
|
self.use_ipc = True
|
|
self._refresh_ipc_board_api()
|
|
logger.info("Switched to IPC backend after KiCAD became available")
|
|
return True
|
|
except Exception as e:
|
|
logger.info(f"Runtime IPC connection not available: {e}")
|
|
return False
|
|
|
|
def _backend_status(self) -> Dict[str, Any]:
|
|
"""Return backend status fields for command responses."""
|
|
ipc_backend = getattr(self, "ipc_backend", None)
|
|
ipc_connected = ipc_backend.is_connected() if ipc_backend else False
|
|
return {
|
|
"backend": "ipc" if self.use_ipc and ipc_connected else "swig",
|
|
"realtime_sync": self.use_ipc and ipc_connected,
|
|
"ipc_connected": ipc_connected,
|
|
}
|
|
|
|
@staticmethod
|
|
def _normalize_ipc_layer_name(layer: Any) -> str:
|
|
"""Convert KiCad IPC layer enum strings to common layer names."""
|
|
layer_name = str(layer)
|
|
if layer_name.startswith("BL_"):
|
|
return layer_name[3:].replace("_", ".")
|
|
return layer_name
|
|
|
|
def _result_backend_for_command(self, command: str, result: Dict[str, Any]) -> str:
|
|
"""Return the backend label for a command result."""
|
|
if command in {
|
|
"get_backend_info",
|
|
"get_backend_state",
|
|
"check_kicad_ui",
|
|
"launch_kicad_ui",
|
|
}:
|
|
return result.get("backend", "ipc" if self.use_ipc else "swig")
|
|
|
|
if command in self.IPC_DIRECT_COMMANDS:
|
|
return "ipc" if self.use_ipc else "unavailable"
|
|
|
|
return "swig"
|
|
|
|
def handle_command(self, command: str, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Route command to appropriate handler, preferring IPC when available"""
|
|
logger.info(f"Handling command: {command}")
|
|
logger.debug(f"Command parameters: {params}")
|
|
|
|
try:
|
|
if command in self.IPC_CAPABLE_COMMANDS:
|
|
self._try_enable_ipc_backend()
|
|
|
|
# Check if we can use IPC for this command (real-time UI sync)
|
|
if self.use_ipc and self.ipc_board_api and command in self.IPC_CAPABLE_COMMANDS:
|
|
ipc_handler_name = self.IPC_CAPABLE_COMMANDS[command]
|
|
ipc_handler = getattr(self, ipc_handler_name, None)
|
|
|
|
if ipc_handler:
|
|
logger.info(f"Using IPC backend for {command} (real-time sync)")
|
|
result = ipc_handler(params)
|
|
|
|
# Add indicator that IPC was used
|
|
if isinstance(result, dict):
|
|
result["_backend"] = "ipc"
|
|
result["_realtime"] = True
|
|
|
|
logger.debug(f"IPC command result: {result}")
|
|
return result
|
|
|
|
# Fall back to SWIG-based handler
|
|
if self.use_ipc and command in self.IPC_CAPABLE_COMMANDS:
|
|
logger.warning(
|
|
f"IPC handler not available for {command}, falling back to SWIG (deprecated)"
|
|
)
|
|
|
|
# Get the handler for the command
|
|
handler = self.command_routes.get(command)
|
|
|
|
if handler:
|
|
# Execute the command
|
|
result = handler(params)
|
|
logger.debug(f"Command result: {result}")
|
|
|
|
# Add backend indicator
|
|
if isinstance(result, dict):
|
|
backend = self._result_backend_for_command(command, result)
|
|
result["_backend"] = backend
|
|
result["_realtime"] = bool(
|
|
backend == "ipc" and result.get("realtime", self.use_ipc)
|
|
)
|
|
|
|
# Update board reference if command was successful
|
|
if result.get("success", False):
|
|
if command == "create_project" or command == "open_project":
|
|
logger.info("Updating board reference...")
|
|
# Get board from the project commands handler
|
|
self.board = self.project_commands.board
|
|
|
|
# Detect SWIG dehydration before claiming success.
|
|
# Without this, every later board op sees a raw
|
|
# SwigPyObject and raises AttributeError, while the
|
|
# MCP keeps reporting "Opened project" — the exact
|
|
# symptom users hit on KiCAD nightlies.
|
|
if not self._is_board_healthy():
|
|
board_path = (result.get("project") or {}).get("boardPath")
|
|
recovered = None
|
|
if board_path:
|
|
logger.warning(
|
|
"Board after %s is SWIG-dehydrated; attempting recovery",
|
|
command,
|
|
)
|
|
recovered = self._safe_load_board(board_path)
|
|
if recovered is not None:
|
|
self.board = recovered
|
|
self.project_commands.board = recovered
|
|
result.setdefault("warnings", []).append(
|
|
"SWIG board proxy was dehydrated on load; "
|
|
"recovered via pcbnew module reload"
|
|
)
|
|
else:
|
|
# Surface the truth — never claim success when
|
|
# the board is unusable.
|
|
return {
|
|
"success": False,
|
|
"message": (
|
|
f"{command} loaded the board but the SWIG "
|
|
"proxy is dehydrated and recovery failed"
|
|
),
|
|
"errorDetails": (
|
|
"pcbnew.LoadBoard returned a BOARD whose "
|
|
"method dispatch is missing (raw SwigPyObject). "
|
|
"This indicates SWIG state corruption in the "
|
|
"current Python process — restart the MCP "
|
|
"server to recover."
|
|
),
|
|
"_backend": "swig",
|
|
"_realtime": False,
|
|
}
|
|
self._update_command_handlers()
|
|
# Record the file's signature so subsequent auto-saves
|
|
# can detect external modifications and refuse to
|
|
# overwrite them.
|
|
self._record_board_signature()
|
|
self._last_auto_save_status = None
|
|
elif command == "save_project":
|
|
self._record_board_signature()
|
|
self._last_auto_save_status = None
|
|
elif command in self._BOARD_MUTATING_COMMANDS:
|
|
# Auto-save after every board mutation via SWIG.
|
|
# Prevents data loss if Claude hits context limit before
|
|
# an explicit save_project call. When auto-save refuses
|
|
# because the on-disk file changed externally, surface
|
|
# a warning to the caller so they don't believe their
|
|
# mutation was persisted.
|
|
save_status = self._auto_save_board()
|
|
self._last_auto_save_status = save_status
|
|
if isinstance(result, dict) and not save_status.get("saved"):
|
|
if save_status.get("warning"):
|
|
result.setdefault("warnings", []).append(save_status["warning"])
|
|
result["autoSave"] = save_status
|
|
|
|
return result
|
|
else:
|
|
logger.error(f"Unknown command: {command}")
|
|
return {
|
|
"success": False,
|
|
"message": f"Unknown command: {command}",
|
|
"errorDetails": "The specified command is not supported",
|
|
}
|
|
|
|
except Exception as e:
|
|
# Get the full traceback
|
|
traceback_str = traceback.format_exc()
|
|
logger.error(f"Error handling command {command}: {str(e)}\n{traceback_str}")
|
|
return {
|
|
"success": False,
|
|
"message": f"Error handling command: {command}",
|
|
"errorDetails": f"{str(e)}\n{traceback_str}",
|
|
}
|
|
|
|
# Board-mutating commands that trigger auto-save on SWIG path
|
|
_BOARD_MUTATING_COMMANDS = {
|
|
"place_component",
|
|
"move_component",
|
|
"rotate_component",
|
|
"delete_component",
|
|
"route_trace",
|
|
"route_arc_trace",
|
|
"route_pad_to_pad",
|
|
"add_via",
|
|
"delete_trace",
|
|
"add_net",
|
|
"add_board_outline",
|
|
"add_mounting_hole",
|
|
"add_text",
|
|
"add_board_text",
|
|
"add_copper_pour",
|
|
"refill_zones",
|
|
"import_svg_logo",
|
|
"sync_schematic_to_board",
|
|
"connect_passthrough",
|
|
"connect_to_net",
|
|
}
|
|
|
|
@staticmethod
|
|
def _disk_signature(path: str) -> Optional[Tuple[int, str]]:
|
|
"""Return (mtime_ns, sha256_hex) for the file, or None if missing/unreadable.
|
|
|
|
The sha256 is always recomputed from disk: the conflict guard in
|
|
``_auto_save_board`` compares hashes (content), not mtime, so we
|
|
cannot use mtime as a cache key without re-introducing the bug
|
|
where two writes inside one mtime tick on a coarse-resolution
|
|
filesystem (FAT32, network mounts, etc.) would mask a real
|
|
content change.
|
|
"""
|
|
try:
|
|
st = os.stat(path)
|
|
h = hashlib.sha256()
|
|
with open(path, "rb") as f:
|
|
for chunk in iter(lambda: f.read(65536), b""):
|
|
h.update(chunk)
|
|
return (st.st_mtime_ns, h.hexdigest())
|
|
except OSError:
|
|
return None
|
|
|
|
def _record_board_signature(self) -> None:
|
|
"""Record the current on-disk signature of self.board's file.
|
|
|
|
Call this after a fresh load (open_project / create_project) or after
|
|
any save we perform ourselves, so that _auto_save_board() can detect
|
|
when an external actor has modified the file in between.
|
|
"""
|
|
if not self.board:
|
|
self._board_disk_signature = None
|
|
return
|
|
try:
|
|
path = self.board.GetFileName()
|
|
except Exception:
|
|
path = None
|
|
self._board_disk_signature = self._disk_signature(path) if path else None
|
|
|
|
def _current_board_path(self) -> Optional[str]:
|
|
"""Return the current board file path, if a healthy board is loaded."""
|
|
board = getattr(self, "board", None)
|
|
if not board or not self._is_board_healthy(board):
|
|
return None
|
|
try:
|
|
path = board.GetFileName()
|
|
except Exception:
|
|
return None
|
|
return os.path.abspath(path) if path else None
|
|
|
|
def _current_project_file_path(self, board_path: Optional[str]) -> Optional[str]:
|
|
"""Best-effort project file path for the currently loaded board."""
|
|
candidates = []
|
|
project_path = getattr(self, "_current_project_path", None)
|
|
|
|
if project_path:
|
|
project_path = Path(project_path)
|
|
if project_path.suffix == ".kicad_pro":
|
|
candidates.append(project_path)
|
|
elif board_path:
|
|
candidates.append(project_path / (Path(board_path).stem + ".kicad_pro"))
|
|
elif project_path.is_dir():
|
|
candidates.extend(project_path.glob("*.kicad_pro"))
|
|
|
|
if board_path and board_path.endswith(".kicad_pcb"):
|
|
candidates.append(Path(board_path).with_suffix(".kicad_pro"))
|
|
|
|
for candidate in candidates:
|
|
if candidate.exists():
|
|
return str(candidate.resolve())
|
|
|
|
return str(Path(candidates[0]).resolve()) if candidates else None
|
|
|
|
def _dirty_state(self, board_path: Optional[str]) -> Dict[str, Any]:
|
|
"""Return the best-known dirty state for the loaded board.
|
|
|
|
dirty is intentionally tri-state: True/False when the MCP has evidence,
|
|
None when no reliable disk signature exists.
|
|
"""
|
|
if not board_path:
|
|
return {
|
|
"dirty": False,
|
|
"dirtyReason": "No board is loaded",
|
|
"diskChangedExternally": False,
|
|
}
|
|
|
|
last_auto_save = getattr(self, "_last_auto_save_status", None) or {}
|
|
if last_auto_save.get("memChangesUnsaved"):
|
|
return {
|
|
"dirty": True,
|
|
"dirtyReason": "Auto-save refused after a board mutation; memory changes are not saved",
|
|
"diskChangedExternally": bool(last_auto_save.get("diskChangedExternally")),
|
|
}
|
|
|
|
expected = getattr(self, "_board_disk_signature", None)
|
|
current = self._disk_signature(board_path)
|
|
|
|
if expected is None:
|
|
return {
|
|
"dirty": None,
|
|
"dirtyReason": "No recorded disk signature for the loaded board",
|
|
"diskChangedExternally": False,
|
|
}
|
|
|
|
if current is None:
|
|
return {
|
|
"dirty": None,
|
|
"dirtyReason": "Board file is missing or unreadable on disk",
|
|
"diskChangedExternally": False,
|
|
}
|
|
|
|
if expected[1] != current[1]:
|
|
return {
|
|
"dirty": True,
|
|
"dirtyReason": "Board file contents changed on disk since this MCP session loaded it",
|
|
"diskChangedExternally": True,
|
|
}
|
|
|
|
return {
|
|
"dirty": False,
|
|
"dirtyReason": "Board file matches the MCP recorded disk signature",
|
|
"diskChangedExternally": False,
|
|
}
|
|
|
|
def _prune_auto_save_backups(self, backup_dir: str, base_name: str) -> None:
|
|
"""Keep only the most recent `_auto_save_backup_keep` backups for `base_name`."""
|
|
try:
|
|
entries = [
|
|
os.path.join(backup_dir, f)
|
|
for f in os.listdir(backup_dir)
|
|
if f.startswith(base_name + ".")
|
|
]
|
|
entries.sort(key=os.path.getmtime, reverse=True)
|
|
for old in entries[self._auto_save_backup_keep :]:
|
|
try:
|
|
os.remove(old)
|
|
except OSError:
|
|
pass
|
|
except OSError as e:
|
|
logger.debug(f"Backup pruning skipped: {e}")
|
|
|
|
def _auto_save_board(self) -> Dict[str, Any]:
|
|
"""Save the in-memory board to disk after a SWIG-path mutation.
|
|
|
|
Behaviour:
|
|
* If the file's on-disk signature has diverged from the one we
|
|
recorded at load (or at our last successful save), refuse to
|
|
overwrite — an external actor (KiCad GUI, another process, git)
|
|
has touched the file and saving would clobber their changes.
|
|
* Otherwise, copy the existing file to ``<dir>/.mcp-backups/<name>.<ts>``
|
|
(rotating, keeps the most recent `_auto_save_backup_keep`),
|
|
then call pcbnew.SaveBoard().
|
|
* Update the recorded signature on success.
|
|
* If SaveBoard leaves the in-memory BOARD dehydrated (observed on
|
|
KiCAD nightlies after delete_trace + auto-save), reload from disk
|
|
so the next command sees a usable proxy instead of a SwigPyObject.
|
|
|
|
Returns a status dict that handle_command merges into the caller's
|
|
response so warnings about refused saves are visible:
|
|
{"saved": True, "boardPath": ..., "backup": <path-or-None>}
|
|
{"saved": False, "skipped": <reason>} -- nothing to save
|
|
{"saved": False, "warning": ..., "diskChangedExternally": True, ...}
|
|
{"saved": False, "error": ...} -- pcbnew error
|
|
"""
|
|
if not self.board:
|
|
return {"saved": False, "skipped": "no board loaded"}
|
|
|
|
try:
|
|
board_path = self.board.GetFileName()
|
|
except Exception as e:
|
|
return {"saved": False, "skipped": f"GetFileName failed: {e}"}
|
|
|
|
if not board_path:
|
|
return {"saved": False, "skipped": "no board path"}
|
|
|
|
expected = self._board_disk_signature
|
|
current = self._disk_signature(board_path)
|
|
|
|
# Only refuse if the file's CONTENT (sha256) has actually diverged
|
|
# from what we recorded. mtime alone is not a conflict signal —
|
|
# `touch`, atime-driven backups, or even some MCP read paths can
|
|
# advance mtime without changing content, and refusing on that
|
|
# basis traps users in a state where every write needs an explicit
|
|
# save_project workaround.
|
|
#
|
|
# If expected is None, treat this as "first save" and proceed —
|
|
# otherwise pre-existing setups (open_project ran before this guard
|
|
# was introduced) would never be able to save.
|
|
if expected is not None and current is not None and expected[1] != current[1]:
|
|
warning = (
|
|
"Auto-save refused: the on-disk PCB file's contents changed "
|
|
"externally since this MCP session loaded it. To avoid "
|
|
"clobbering those changes, the in-memory mutation has NOT "
|
|
"been written to disk. Reload via open_project to refresh, "
|
|
"then re-apply the change."
|
|
)
|
|
logger.warning(f"{warning} ({board_path})")
|
|
logger.warning(f" expected sha256={expected[1][:12]}… mtime_ns={expected[0]}")
|
|
logger.warning(f" current sha256={current[1][:12]}… mtime_ns={current[0]}")
|
|
return {
|
|
"saved": False,
|
|
"warning": warning,
|
|
"boardPath": board_path,
|
|
"diskChangedExternally": True,
|
|
"expectedMtimeNs": expected[0],
|
|
"currentMtimeNs": current[0],
|
|
"memChangesUnsaved": True,
|
|
}
|
|
|
|
# Content matches but mtime advanced (e.g. external `touch`): refresh
|
|
# the recorded mtime so we don't re-hash on every subsequent call.
|
|
if expected is not None and current is not None and expected != current:
|
|
self._board_disk_signature = current
|
|
|
|
# Make a rotating backup of the existing file (best-effort).
|
|
backup_path: Optional[str] = None
|
|
if current is not None:
|
|
try:
|
|
backup_dir = os.path.join(os.path.dirname(board_path) or ".", ".mcp-backups")
|
|
os.makedirs(backup_dir, exist_ok=True)
|
|
stamp = datetime.now().strftime("%Y%m%d-%H%M%S-%f")[:-3]
|
|
base = os.path.basename(board_path)
|
|
backup_path = os.path.join(backup_dir, f"{base}.{stamp}")
|
|
shutil.copy2(board_path, backup_path)
|
|
self._prune_auto_save_backups(backup_dir, base)
|
|
except OSError as e:
|
|
logger.warning(f"Auto-save backup failed (continuing): {e}")
|
|
backup_path = None
|
|
|
|
# Write the board.
|
|
try:
|
|
pcbnew.SaveBoard(board_path, self.board)
|
|
logger.debug(f"Auto-saved board to: {board_path}")
|
|
self._board_disk_signature = self._disk_signature(board_path)
|
|
except Exception as e:
|
|
logger.warning(f"Auto-save failed: {e}")
|
|
return {"saved": False, "error": str(e), "backup": backup_path}
|
|
|
|
# Post-save dehydration check. If the BOARD lost its bindings during
|
|
# save, reload from disk while we still know the path. board_path is
|
|
# guaranteed non-empty here (we returned early above otherwise).
|
|
if not self._is_board_healthy():
|
|
logger.warning(
|
|
"Board became dehydrated during auto-save; reloading from %s",
|
|
board_path,
|
|
)
|
|
recovered = self._safe_load_board(board_path)
|
|
if recovered is not None:
|
|
self.board = recovered
|
|
self._update_command_handlers()
|
|
else:
|
|
logger.error(
|
|
"Board dehydration after auto-save is unrecoverable — "
|
|
"subsequent commands will fail until MCP restart"
|
|
)
|
|
|
|
return {"saved": True, "boardPath": board_path, "backup": backup_path}
|
|
|
|
def _update_command_handlers(self) -> None:
|
|
"""Update board reference in all command handlers"""
|
|
logger.debug("Updating board reference in command handlers")
|
|
self.project_commands.board = self.board
|
|
self.board_commands.board = self.board
|
|
self.component_commands.board = self.board
|
|
self.routing_commands.board = self.board
|
|
self.design_rule_commands.board = self.board
|
|
self.export_commands.board = self.board
|
|
self.freerouting_commands.board = self.board
|
|
|
|
# Stable BOARD methods used to detect SWIG dehydration. Newer KiCAD nightly
|
|
# builds occasionally return a raw SwigPyObject from pcbnew.LoadBoard after
|
|
# certain mutating sequences (delete_trace, refill_zones, …) — the proxy
|
|
# type-checks but every method access raises AttributeError. Probing for
|
|
# these methods catches that state without segfaulting.
|
|
_BOARD_HEALTH_METHODS = (
|
|
"GetDesignSettings",
|
|
"GetBoardEdgesBoundingBox",
|
|
"GetFileName",
|
|
)
|
|
|
|
def _is_board_healthy(self, board: Optional[Any] = None) -> bool:
|
|
"""Return True if the board (default self.board) has live SWIG dispatch."""
|
|
target = board if board is not None else self.board
|
|
if target is None:
|
|
return False
|
|
return all(hasattr(target, m) for m in self._BOARD_HEALTH_METHODS)
|
|
|
|
def _safe_load_board(self, path: str) -> Optional[Any]:
|
|
"""Load a board from disk, recovering from SWIG dehydration if pcbnew is broken.
|
|
|
|
If pcbnew.LoadBoard returns a dehydrated proxy, reload the pcbnew
|
|
module once and retry. Returns the new board, or None if recovery
|
|
is impossible (caller must surface a real failure rather than fake
|
|
success).
|
|
"""
|
|
global pcbnew
|
|
try:
|
|
board = pcbnew.LoadBoard(path)
|
|
except Exception as e:
|
|
logger.error(f"LoadBoard({path!r}) raised: {e}")
|
|
return None
|
|
|
|
if self._is_board_healthy(board):
|
|
return board
|
|
|
|
logger.warning(
|
|
f"LoadBoard({path!r}) returned a dehydrated SWIG proxy; "
|
|
"reloading pcbnew module and retrying"
|
|
)
|
|
try:
|
|
import importlib
|
|
|
|
pcbnew = importlib.reload(pcbnew)
|
|
except Exception as e:
|
|
logger.error(f"pcbnew module reload failed: {e}")
|
|
return None
|
|
|
|
try:
|
|
board = pcbnew.LoadBoard(path)
|
|
except Exception as e:
|
|
logger.error(f"LoadBoard retry after pcbnew reload failed: {e}")
|
|
return None
|
|
|
|
if not self._is_board_healthy(board):
|
|
logger.error(
|
|
"Board still dehydrated after pcbnew reload; SWIG state is "
|
|
"unrecoverable in this process — restart the MCP server"
|
|
)
|
|
return None
|
|
|
|
logger.info("Recovered from SWIG dehydration via pcbnew reload")
|
|
return board
|
|
|
|
# Schematic command handlers
|
|
def _handle_create_schematic(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Create a new schematic"""
|
|
logger.info("Creating schematic")
|
|
try:
|
|
# Support multiple parameter naming conventions for compatibility:
|
|
# - TypeScript tools use: name, path
|
|
# - Python schema uses: filename, title
|
|
# - Legacy uses: projectName, path, metadata
|
|
project_name = params.get("projectName") or params.get("name") or params.get("title")
|
|
|
|
# Handle filename parameter - it may contain full path
|
|
filename = params.get("filename")
|
|
if filename:
|
|
# If filename provided, extract name and path from it
|
|
if filename.endswith(".kicad_sch"):
|
|
filename = filename[:-10] # Remove .kicad_sch extension
|
|
path = os.path.dirname(filename) or "."
|
|
project_name = project_name or os.path.basename(filename)
|
|
else:
|
|
path = params.get("path", ".")
|
|
metadata = params.get("metadata", {})
|
|
|
|
if not project_name:
|
|
return {
|
|
"success": False,
|
|
"message": "Schematic name is required. Provide 'name', 'projectName', or 'filename' parameter.",
|
|
}
|
|
|
|
sch_path = path if path and path != "." else None
|
|
schematic = SchematicManager.create_schematic(
|
|
project_name, path=sch_path, metadata=metadata
|
|
)
|
|
base_name = (
|
|
project_name if project_name.endswith(".kicad_sch") else f"{project_name}.kicad_sch"
|
|
)
|
|
normalized_path = path or "."
|
|
file_path = os.path.join(normalized_path, base_name)
|
|
success = SchematicManager.save_schematic(schematic, file_path)
|
|
|
|
return {"success": success, "file_path": file_path}
|
|
except Exception as e:
|
|
logger.error(f"Error creating schematic: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_load_schematic(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Load an existing schematic"""
|
|
logger.info("Loading schematic")
|
|
try:
|
|
filename = params.get("filename")
|
|
|
|
if not filename:
|
|
return {"success": False, "message": "Filename is required"}
|
|
|
|
schematic = SchematicManager.load_schematic(filename)
|
|
success = schematic is not None
|
|
|
|
if success:
|
|
metadata = SchematicManager.get_schematic_metadata(schematic)
|
|
return {"success": success, "metadata": metadata}
|
|
else:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
except Exception as e:
|
|
logger.error(f"Error loading schematic: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _project_path_from_filename(self, filename: Optional[str]) -> Optional[Path]:
|
|
"""Resolve a project directory from a filename param.
|
|
|
|
Accepts a .kicad_pro file, a .kicad_pcb file, or a directory.
|
|
"""
|
|
if not filename:
|
|
return None
|
|
try:
|
|
p = Path(filename).expanduser()
|
|
except Exception:
|
|
return None
|
|
if p.is_file() or p.suffix in (".kicad_pro", ".kicad_pcb", ".kicad_sch"):
|
|
return p.parent
|
|
return p
|
|
|
|
def _refresh_symbol_library_for_project(self, project_path: Optional[Path]) -> None:
|
|
"""Rebuild SymbolLibraryCommands' manager so project-scope sym-lib-table
|
|
is visible to subsequent search/list/info calls. No-op if unchanged."""
|
|
if project_path is None:
|
|
return
|
|
self._current_project_path = project_path
|
|
try:
|
|
self.symbol_library_commands.use_project(project_path)
|
|
except Exception as e:
|
|
logger.warning(f"Failed to refresh symbol library for project {project_path}: {e}")
|
|
|
|
def _handle_open_project(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Wrap project_commands.open_project so project-scope symbol libraries
|
|
become visible to subsequent search_symbols / list_symbol_libraries /
|
|
get_symbol_info calls."""
|
|
result = self.project_commands.open_project(params)
|
|
if result.get("success"):
|
|
project_info = result.get("project") or {}
|
|
project_path = self._project_path_from_filename(
|
|
project_info.get("path") or project_info.get("boardPath") or params.get("filename")
|
|
)
|
|
self._refresh_symbol_library_for_project(project_path)
|
|
return result
|
|
|
|
def _handle_create_project(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Wrap project_commands.create_project for the same reason as open_project."""
|
|
result = self.project_commands.create_project(params)
|
|
if result.get("success"):
|
|
project_info = result.get("project") or {}
|
|
project_path = self._project_path_from_filename(
|
|
project_info.get("path")
|
|
or project_info.get("boardPath")
|
|
or params.get("path")
|
|
or params.get("filename")
|
|
)
|
|
self._refresh_symbol_library_for_project(project_path)
|
|
return result
|
|
|
|
def _handle_place_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Place a component on the PCB, with project-local fp-lib-table support.
|
|
If boardPath is given and differs from the currently loaded board, the
|
|
board is reloaded from boardPath before placing — prevents silent failures
|
|
when Claude provides a boardPath that was not yet loaded.
|
|
"""
|
|
from pathlib import Path
|
|
|
|
board_path = params.get("boardPath")
|
|
if board_path:
|
|
board_path_norm = str(Path(board_path).resolve())
|
|
current_board_file = str(Path(self.board.GetFileName()).resolve()) if self.board else ""
|
|
if board_path_norm != current_board_file:
|
|
logger.info(f"boardPath differs from current board — reloading: {board_path}")
|
|
reloaded = self._safe_load_board(board_path)
|
|
if reloaded is None:
|
|
return {
|
|
"success": False,
|
|
"message": f"Could not load board from boardPath: {board_path}",
|
|
"errorDetails": (
|
|
"pcbnew.LoadBoard failed or returned a dehydrated "
|
|
"SWIG proxy that could not be recovered"
|
|
),
|
|
}
|
|
self.board = reloaded
|
|
self._update_command_handlers()
|
|
logger.info("Board reloaded from boardPath")
|
|
|
|
project_path = Path(board_path).parent
|
|
if project_path != getattr(self, "_current_project_path", None):
|
|
self._current_project_path = project_path
|
|
local_lib = FootprintLibraryManager(project_path=project_path)
|
|
self.component_commands = ComponentCommands(self.board, local_lib)
|
|
logger.info(f"Reloaded FootprintLibraryManager with project_path={project_path}")
|
|
|
|
return self.component_commands.place_component(params)
|
|
|
|
def _handle_add_schematic_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a component to a schematic using text-based injection (no sexpdata)"""
|
|
logger.info("Adding component to schematic")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.dynamic_symbol_loader import DynamicSymbolLoader
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
component = params.get("component", {})
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "Schematic path is required"}
|
|
if not component:
|
|
return {"success": False, "message": "Component definition is required"}
|
|
|
|
comp_type = component.get("type", "R")
|
|
library = component.get("library", "Device")
|
|
reference = component.get("reference", "X?")
|
|
value = component.get("value", comp_type)
|
|
footprint = component.get("footprint", "")
|
|
x = component.get("x", 0)
|
|
y = component.get("y", 0)
|
|
unit = component.get("unit", 1)
|
|
|
|
# Derive project path from schematic path for project-local library resolution.
|
|
# Walk up from the schematic file to find the directory that owns the project
|
|
# (contains sym-lib-table or a .kicad_pro file). Schematics stored in a
|
|
# sub-folder (e.g. sheets/) would otherwise resolve to the wrong directory and
|
|
# miss any project-local sym-lib-table entries.
|
|
schematic_file = Path(schematic_path)
|
|
derived_project_path = schematic_file.parent
|
|
for ancestor in schematic_file.parents:
|
|
if (ancestor / "sym-lib-table").exists() or list(ancestor.glob("*.kicad_pro")):
|
|
derived_project_path = ancestor
|
|
break
|
|
|
|
loader = DynamicSymbolLoader(project_path=derived_project_path)
|
|
loader.add_component(
|
|
schematic_file,
|
|
library,
|
|
comp_type,
|
|
reference=reference,
|
|
value=value,
|
|
footprint=footprint,
|
|
x=x,
|
|
y=y,
|
|
unit=unit,
|
|
project_path=derived_project_path,
|
|
)
|
|
|
|
return {
|
|
"success": True,
|
|
"component_reference": reference,
|
|
"symbol_source": f"{library}:{comp_type}",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error adding component to schematic: {str(e)}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_delete_schematic_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Remove a placed symbol from a schematic using text-based manipulation (no skip writes)"""
|
|
logger.info("Deleting schematic component")
|
|
try:
|
|
import re
|
|
from pathlib import Path
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
reference = params.get("reference")
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
if not reference:
|
|
return {"success": False, "message": "reference is required"}
|
|
|
|
sch_file = Path(schematic_path)
|
|
if not sch_file.exists():
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
with open(sch_file, "r", encoding="utf-8") as f:
|
|
content = f.read()
|
|
|
|
# String-aware paren matcher (see _find_matching_paren): a naive
|
|
# counter over-runs on unescaped parens inside quoted strings (e.g.
|
|
# MCU pin names like "PA13(JTMS"), which would extend lib_symbols to
|
|
# EOF and make every placed-symbol lookup fail.
|
|
find_matching_paren = self._find_matching_paren
|
|
|
|
# Skip lib_symbols section
|
|
lib_sym_pos = content.find("(lib_symbols")
|
|
lib_sym_end = find_matching_paren(content, lib_sym_pos) if lib_sym_pos >= 0 else -1
|
|
|
|
# Find ALL placed symbol blocks matching the reference (handles duplicates).
|
|
# Use content-string search so multi-line KiCAD format is handled correctly:
|
|
# KiCAD writes (symbol\n\t\t(lib_id "...") across two lines, which a
|
|
# line-by-line regex would never match.
|
|
blocks_to_delete = [] # list of (char_start, char_end) into content
|
|
search_start = 0
|
|
# Match the opening of any placed-symbol block. KiCAD may emit the
|
|
# children of (symbol ...) in any order — most commonly
|
|
# `(symbol (lib_id "..."))`, but symbols whose library entry has been
|
|
# rescued / customised carry an additional `(lib_name "...")` first:
|
|
# `(symbol (lib_name "...") (lib_id "...") ...)`. Matching just
|
|
# `(symbol\s+(` covers both, and the lib_symbols range check below
|
|
# still excludes library-definition symbols (which use the
|
|
# `(symbol "name" ...)` form with a quoted string, not a paren).
|
|
pattern = re.compile(r"\(symbol\s+\(")
|
|
while True:
|
|
m = pattern.search(content, search_start)
|
|
if not m:
|
|
break
|
|
pos = m.start()
|
|
# Skip blocks inside lib_symbols
|
|
if lib_sym_pos >= 0 and lib_sym_pos <= pos <= lib_sym_end:
|
|
search_start = lib_sym_end + 1
|
|
continue
|
|
end = find_matching_paren(content, pos)
|
|
if end < 0:
|
|
search_start = pos + 1
|
|
continue
|
|
block_text = content[pos : end + 1]
|
|
if re.search(
|
|
r'\(property\s+"Reference"\s+"' + re.escape(reference) + r'"',
|
|
block_text,
|
|
):
|
|
blocks_to_delete.append((pos, end))
|
|
search_start = end + 1
|
|
|
|
if not blocks_to_delete:
|
|
return {
|
|
"success": False,
|
|
"message": f"Component '{reference}' not found in schematic (note: this tool removes schematic symbols, use delete_component for PCB footprints)",
|
|
}
|
|
|
|
# Delete from back to front to preserve character offsets
|
|
for b_start, b_end in sorted(blocks_to_delete, reverse=True):
|
|
# Include any leading newline/whitespace before the block
|
|
trim_start = b_start
|
|
while trim_start > 0 and content[trim_start - 1] in (" ", "\t"):
|
|
trim_start -= 1
|
|
if trim_start > 0 and content[trim_start - 1] == "\n":
|
|
trim_start -= 1
|
|
content = content[:trim_start] + content[b_end + 1 :]
|
|
|
|
with open(sch_file, "w", encoding="utf-8") as f:
|
|
f.write(content)
|
|
|
|
deleted_count = len(blocks_to_delete)
|
|
logger.info(f"Deleted {deleted_count} instance(s) of {reference} from {sch_file.name}")
|
|
return {
|
|
"success": True,
|
|
"reference": reference,
|
|
"deleted_count": deleted_count,
|
|
"schematic": str(sch_file),
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error deleting schematic component: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
# Built-in property names that have dedicated parameters and cannot be removed
|
|
# via the generic removeProperties path. They are also written by KiCad on every
|
|
# save, so deleting them produces an invalid schematic.
|
|
_PROTECTED_PROPERTY_FIELDS = frozenset({"Reference", "Value", "Footprint", "Datasheet"})
|
|
|
|
@staticmethod
|
|
def _escape_sexpr_string(value: str) -> str:
|
|
"""Escape a string for safe insertion into an S-expression double-quoted token."""
|
|
return value.replace("\\", "\\\\").replace('"', '\\"')
|
|
|
|
@staticmethod
|
|
def _find_matching_paren(s: str, start: int) -> int:
|
|
"""Return the index of the closing paren matching the opening paren at `start`.
|
|
|
|
String-aware: parens inside double-quoted tokens are ignored. KiCAD does
|
|
NOT backslash-escape bare parens inside quoted strings — e.g. MCU pin
|
|
names like "PA13(JTMS" or descriptions like "Vin(fwd) 40V" appear raw in
|
|
.kicad_sch / .kicad_sym files. A naive depth counter treats such an
|
|
in-string "(" as real structure, so it never rebalances and runs to EOF.
|
|
When that happens to the (lib_symbols ...) block, every placed symbol —
|
|
which follows lib_symbols — looks like it lives *inside* it and gets
|
|
skipped, so reference lookups silently fail for the whole schematic.
|
|
|
|
Returns -1 if no match is found.
|
|
"""
|
|
depth = 0
|
|
i = start
|
|
in_string = False
|
|
while i < len(s):
|
|
ch = s[i]
|
|
if in_string:
|
|
if ch == "\\":
|
|
i += 2 # skip escaped char (e.g. \" or \\)
|
|
continue
|
|
if ch == '"':
|
|
in_string = False
|
|
elif ch == '"':
|
|
in_string = True
|
|
elif ch == "(":
|
|
depth += 1
|
|
elif ch == ")":
|
|
depth -= 1
|
|
if depth == 0:
|
|
return i
|
|
i += 1
|
|
return -1
|
|
|
|
def _set_property_in_block(
|
|
self,
|
|
block: str,
|
|
name: str,
|
|
spec: Dict[str, Any],
|
|
default_position: Tuple[float, float],
|
|
) -> Tuple[str, str]:
|
|
"""Add or update a property within a placed-symbol block.
|
|
|
|
Args:
|
|
block: The full text of the (symbol ...) block.
|
|
name: Property name (e.g. "MPN", "Manufacturer").
|
|
spec: Dict that may contain keys: value, x, y, angle, hide, fontSize,
|
|
justify. ``justify`` is a space-separated string of KiCad
|
|
alignment keywords (e.g. "left", "right top"). "center" removes
|
|
the directive (KiCad default).
|
|
default_position: (x, y) of the parent symbol — used as the default
|
|
location for newly-created properties so the field is anchored
|
|
near the component, not at (0, 0).
|
|
|
|
Returns:
|
|
Tuple of (new_block_text, action_taken) where action is "added" or "updated".
|
|
"""
|
|
import re
|
|
|
|
new_value = spec.get("value")
|
|
new_x = spec.get("x")
|
|
new_y = spec.get("y")
|
|
new_angle = spec.get("angle")
|
|
new_hide = spec.get("hide")
|
|
new_justify = spec.get("justify")
|
|
font_size = spec.get("fontSize", 1.27)
|
|
|
|
existing_match = re.search(
|
|
r'\(property\s+"' + re.escape(name) + r'"\s+"',
|
|
block,
|
|
)
|
|
|
|
if existing_match:
|
|
# Property exists — patch value / position / hide in place
|
|
if new_value is not None:
|
|
escaped = self._escape_sexpr_string(str(new_value))
|
|
block = re.sub(
|
|
r'(\(property\s+"' + re.escape(name) + r'"\s+)"[^"]*"',
|
|
rf'\1"{escaped}"',
|
|
block,
|
|
count=1,
|
|
)
|
|
|
|
if new_x is not None or new_y is not None or new_angle is not None:
|
|
pos_match = re.search(
|
|
r'(\(property\s+"'
|
|
+ re.escape(name)
|
|
+ r'"\s+"[^"]*"\s+\(at\s+)([\d\.\-]+)\s+([\d\.\-]+)\s+([\d\.\-]+)(\s*\))',
|
|
block,
|
|
)
|
|
if pos_match:
|
|
cx = new_x if new_x is not None else float(pos_match.group(2))
|
|
cy = new_y if new_y is not None else float(pos_match.group(3))
|
|
ca = new_angle if new_angle is not None else float(pos_match.group(4))
|
|
block = (
|
|
block[: pos_match.start()]
|
|
+ pos_match.group(1)
|
|
+ f"{cx} {cy} {ca}"
|
|
+ pos_match.group(5)
|
|
+ block[pos_match.end() :]
|
|
)
|
|
|
|
if new_hide is not None:
|
|
block = self._set_hide_on_property(block, name, bool(new_hide))
|
|
|
|
if new_justify is not None:
|
|
block = self._set_justify_on_property(block, name, str(new_justify))
|
|
|
|
return block, "updated"
|
|
|
|
# Property does not exist — append a new one after the last existing property
|
|
if new_value is None:
|
|
# Adding a brand-new property requires at least a value
|
|
raise ValueError(
|
|
f"Property '{name}' does not exist on this component yet — supply a value to create it"
|
|
)
|
|
|
|
cx = new_x if new_x is not None else default_position[0]
|
|
cy = new_y if new_y is not None else default_position[1]
|
|
ca = new_angle if new_angle is not None else 0
|
|
# New properties default to hidden (BOM/sourcing data normally has no
|
|
# visible footprint on the schematic canvas).
|
|
hide_str = "(hide yes)" if (new_hide is None or new_hide) else "(hide no)"
|
|
escaped = self._escape_sexpr_string(str(new_value))
|
|
escaped_name = self._escape_sexpr_string(str(name))
|
|
|
|
# Build optional (justify ...) token for the effects block.
|
|
justify_str = ""
|
|
if new_justify is not None:
|
|
tokens = str(new_justify).strip().split()
|
|
if not all(t == "center" for t in tokens):
|
|
justify_str = f" (justify {str(new_justify).strip()})"
|
|
|
|
new_prop = (
|
|
f' (property "{escaped_name}" "{escaped}" (at {cx} {cy} {ca})\n'
|
|
f" (effects (font (size {font_size} {font_size})){justify_str} {hide_str})\n"
|
|
f" )"
|
|
)
|
|
|
|
# Find the last existing property block and insert immediately after it.
|
|
last_prop_end = -1
|
|
for m in re.finditer(r'\(property\s+"', block):
|
|
end = self._find_matching_paren(block, m.start())
|
|
if end > last_prop_end:
|
|
last_prop_end = end
|
|
|
|
if last_prop_end < 0:
|
|
# No properties at all — insert just before the closing paren of the symbol
|
|
block_close = block.rfind(")")
|
|
if block_close < 0:
|
|
raise ValueError("Malformed symbol block: no closing paren")
|
|
block = block[:block_close] + "\n" + new_prop + "\n " + block[block_close:]
|
|
else:
|
|
block = block[: last_prop_end + 1] + "\n" + new_prop + block[last_prop_end + 1 :]
|
|
|
|
return block, "added"
|
|
|
|
def _set_hide_on_property(self, block: str, name: str, hide: bool) -> str:
|
|
"""Set the (hide yes|no) flag on a named property's effects clause.
|
|
|
|
Handles three pre-existing forms:
|
|
(effects (font (size 1.27 1.27))) — no hide flag
|
|
(effects (font (size 1.27 1.27)) hide) — legacy bare token
|
|
(effects (font (size 1.27 1.27)) (hide yes|no)) — KiCad 9 form
|
|
"""
|
|
import re
|
|
|
|
prop_match = re.search(
|
|
r'\(property\s+"' + re.escape(name) + r'"',
|
|
block,
|
|
)
|
|
if not prop_match:
|
|
return block
|
|
prop_start = prop_match.start()
|
|
prop_end = self._find_matching_paren(block, prop_start)
|
|
if prop_end < 0:
|
|
return block
|
|
|
|
# Locate the (effects ...) clause inside the property
|
|
prop_segment = block[prop_start : prop_end + 1]
|
|
eff_match = re.search(r"\(effects\b", prop_segment)
|
|
if not eff_match:
|
|
return block
|
|
eff_start = prop_start + eff_match.start()
|
|
eff_end = self._find_matching_paren(block, eff_start)
|
|
if eff_end < 0:
|
|
return block
|
|
|
|
eff_inner = block[eff_start + 1 : eff_end] # 'effects (font ...) ...'
|
|
eff_inner = re.sub(r"\s*\(hide\s+(yes|no)\)", "", eff_inner)
|
|
eff_inner = re.sub(r"\s+hide\b(?!\s+(yes|no))", "", eff_inner)
|
|
eff_inner = eff_inner.rstrip() + f' (hide {"yes" if hide else "no"})'
|
|
|
|
new_effects = "(" + eff_inner + ")"
|
|
return block[:eff_start] + new_effects + block[eff_end + 1 :]
|
|
|
|
def _set_justify_on_property(self, block: str, name: str, justify: str) -> str:
|
|
"""Set or clear the (justify ...) directive on a named property's effects clause.
|
|
|
|
``justify`` is a space-separated string of KiCad alignment keywords:
|
|
horizontal: "left" | "right" | "center"
|
|
vertical: "top" | "bottom" | "center"
|
|
Any combination of one or two tokens is accepted, e.g. "left", "right top".
|
|
Passing "center" (the KiCad default) removes the (justify ...) directive
|
|
entirely, which is how KiCad represents centered alignment.
|
|
|
|
Handles effects clauses that already contain a (justify ...) token, and
|
|
those that do not.
|
|
"""
|
|
import re
|
|
|
|
prop_match = re.search(
|
|
r'\(property\s+"' + re.escape(name) + r'"',
|
|
block,
|
|
)
|
|
if not prop_match:
|
|
return block
|
|
prop_start = prop_match.start()
|
|
prop_end = self._find_matching_paren(block, prop_start)
|
|
if prop_end < 0:
|
|
return block
|
|
|
|
prop_segment = block[prop_start : prop_end + 1]
|
|
eff_match = re.search(r"\(effects\b", prop_segment)
|
|
if not eff_match:
|
|
return block
|
|
eff_start = prop_start + eff_match.start()
|
|
eff_end = self._find_matching_paren(block, eff_start)
|
|
if eff_end < 0:
|
|
return block
|
|
|
|
eff_inner = block[eff_start + 1 : eff_end] # 'effects (font ...) ...'
|
|
# Remove any pre-existing (justify ...) token
|
|
eff_inner = re.sub(r"\s*\(justify\b[^)]*\)", "", eff_inner)
|
|
# "center" is the KiCad default — omitting the directive means centered
|
|
tokens = justify.strip().split()
|
|
is_center_only = all(t == "center" for t in tokens)
|
|
if not is_center_only:
|
|
eff_inner = eff_inner.rstrip() + f" (justify {justify.strip()})"
|
|
|
|
new_effects = "(" + eff_inner + ")"
|
|
return block[:eff_start] + new_effects + block[eff_end + 1 :]
|
|
|
|
def _remove_property_from_block(self, block: str, name: str) -> Tuple[str, bool]:
|
|
"""Remove a property from the symbol block. Returns (new_block, removed_bool)."""
|
|
import re
|
|
|
|
m = re.search(r'\(property\s+"' + re.escape(name) + r'"\s+"', block)
|
|
if not m:
|
|
return block, False
|
|
start = m.start()
|
|
end = self._find_matching_paren(block, start)
|
|
if end < 0:
|
|
return block, False
|
|
|
|
# Trim surrounding whitespace (leading newline + indent) so the resulting
|
|
# file does not develop blank lines after every removal.
|
|
trim_start = start
|
|
while trim_start > 0 and block[trim_start - 1] in (" ", "\t"):
|
|
trim_start -= 1
|
|
if trim_start > 0 and block[trim_start - 1] == "\n":
|
|
trim_start -= 1
|
|
return block[:trim_start] + block[end + 1 :], True
|
|
|
|
def _handle_edit_schematic_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Update properties of a placed symbol in a schematic.
|
|
|
|
Supports updating the standard fields (footprint / value / reference rename),
|
|
repositioning field labels, and managing **arbitrary custom properties**
|
|
(MPN, Manufacturer, Distributor part numbers, Voltage, Dielectric, Tolerance,
|
|
LCSC, etc.) used by BOM/CPL exporters and JLCPCB / Digi-Key sourcing.
|
|
|
|
Uses text-based in-place editing — preserves position, UUID, and all
|
|
unrelated fields.
|
|
"""
|
|
logger.info("Editing schematic component")
|
|
try:
|
|
import re
|
|
from pathlib import Path
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
reference = params.get("reference")
|
|
new_footprint = params.get("footprint")
|
|
new_value = params.get("value")
|
|
new_reference = params.get("newReference")
|
|
# dict: {"Reference": {"x": 1, "y": 2, "angle": 0}}
|
|
field_positions = params.get("fieldPositions")
|
|
# dict: {"MPN": "RC0603FR-0710KL"} OR {"MPN": {"value": "...", "hide": true}}
|
|
properties = params.get("properties")
|
|
# list[str]: ["OldField"] — protected built-ins are rejected
|
|
remove_properties = params.get("removeProperties")
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
if not reference:
|
|
return {"success": False, "message": "reference is required"}
|
|
if not any(
|
|
[
|
|
new_footprint is not None,
|
|
new_value is not None,
|
|
new_reference is not None,
|
|
field_positions is not None,
|
|
properties is not None,
|
|
remove_properties is not None,
|
|
]
|
|
):
|
|
return {
|
|
"success": False,
|
|
"message": (
|
|
"At least one of footprint, value, newReference, fieldPositions, "
|
|
"properties, or removeProperties must be provided"
|
|
),
|
|
}
|
|
|
|
# Reject removal attempts targeting protected built-in fields up-front
|
|
if remove_properties:
|
|
blocked = [n for n in remove_properties if n in self._PROTECTED_PROPERTY_FIELDS]
|
|
if blocked:
|
|
return {
|
|
"success": False,
|
|
"message": (
|
|
f"Cannot remove built-in field(s) {blocked}: use the dedicated "
|
|
"value/footprint/newReference parameters or set the value to ''"
|
|
),
|
|
}
|
|
|
|
sch_file = Path(schematic_path)
|
|
if not sch_file.exists():
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
with open(sch_file, "r", encoding="utf-8") as f:
|
|
content = f.read()
|
|
|
|
# Skip lib_symbols section
|
|
lib_sym_pos = content.find("(lib_symbols")
|
|
lib_sym_end = (
|
|
self._find_matching_paren(content, lib_sym_pos) if lib_sym_pos >= 0 else -1
|
|
)
|
|
|
|
# Find placed symbol blocks that match the reference. KiCAD may
|
|
# serialise the children of (symbol ...) in different orders —
|
|
# `(symbol (lib_id "..."))` is the common case but rescued or
|
|
# locally-customised symbols carry an extra `(lib_name "...")`
|
|
# before the lib_id: `(symbol (lib_name "...") (lib_id "..."))`.
|
|
# Match any opening paren after `(symbol`; the lib_symbols range
|
|
# check below excludes library-definition symbols, which use the
|
|
# `(symbol "name" ...)` form (quoted string, not paren).
|
|
block_start = block_end = None
|
|
search_start = 0
|
|
pattern = re.compile(r"\(symbol\s+\(")
|
|
while True:
|
|
m = pattern.search(content, search_start)
|
|
if not m:
|
|
break
|
|
pos = m.start()
|
|
# Skip if inside lib_symbols section
|
|
if lib_sym_pos >= 0 and lib_sym_pos <= pos <= lib_sym_end:
|
|
search_start = lib_sym_end + 1
|
|
continue
|
|
end = self._find_matching_paren(content, pos)
|
|
if end < 0:
|
|
search_start = pos + 1
|
|
continue
|
|
block_text = content[pos : end + 1]
|
|
if re.search(
|
|
r'\(property\s+"Reference"\s+"' + re.escape(reference) + r'"',
|
|
block_text,
|
|
):
|
|
block_start, block_end = pos, end
|
|
break
|
|
search_start = end + 1
|
|
|
|
if block_start is None or block_end is None:
|
|
return {
|
|
"success": False,
|
|
"message": f"Component '{reference}' not found in schematic",
|
|
}
|
|
|
|
# Apply property replacements within the found block
|
|
block_text = content[block_start : block_end + 1]
|
|
|
|
# Determine the parent symbol position so that newly-added properties
|
|
# default to a sensible location (anchored near the component).
|
|
# KiCAD always emits the symbol's own (at x y angle) before any
|
|
# (property ...) child blocks, so the FIRST (at ...) inside the
|
|
# symbol block is the symbol origin regardless of whether
|
|
# (lib_name ...) precedes (lib_id ...).
|
|
comp_at = re.search(
|
|
r"\(at\s+([\d\.\-]+)\s+([\d\.\-]+)",
|
|
block_text,
|
|
)
|
|
comp_origin: Tuple[float, float] = (
|
|
(float(comp_at.group(1)), float(comp_at.group(2))) if comp_at else (0.0, 0.0)
|
|
)
|
|
|
|
if new_footprint is not None:
|
|
escaped_fp = self._escape_sexpr_string(str(new_footprint))
|
|
block_text = re.sub(
|
|
r'(\(property\s+"Footprint"\s+)"[^"]*"',
|
|
rf'\1"{escaped_fp}"',
|
|
block_text,
|
|
)
|
|
if new_value is not None:
|
|
escaped_v = self._escape_sexpr_string(str(new_value))
|
|
block_text = re.sub(
|
|
r'(\(property\s+"Value"\s+)"[^"]*"',
|
|
rf'\1"{escaped_v}"',
|
|
block_text,
|
|
)
|
|
if new_reference is not None:
|
|
escaped_r = self._escape_sexpr_string(str(new_reference))
|
|
block_text = re.sub(
|
|
r'(\(property\s+"Reference"\s+)"[^"]*"',
|
|
rf'\1"{escaped_r}"',
|
|
block_text,
|
|
)
|
|
# Also update the (reference "...") leaves inside the symbol's
|
|
# (instances) → (project) → (path) subtree. KiCad reads those
|
|
# entries — not the (property "Reference" ...) field — when
|
|
# generating netlists and syncing the PCB via "Update PCB from
|
|
# Schematic", so leaving them stale produces a silent
|
|
# reference mismatch where eeschema shows the new ref but ERC
|
|
# / netlist export / PCB sync all use the old one. See #126.
|
|
instances_pos = block_text.find("(instances")
|
|
if instances_pos >= 0:
|
|
instances_end = self._find_matching_paren(block_text, instances_pos)
|
|
if instances_end >= 0:
|
|
instances_block = block_text[instances_pos : instances_end + 1]
|
|
updated_instances = re.sub(
|
|
r'(\(reference\s+)"' + re.escape(reference) + r'"',
|
|
rf'\1"{escaped_r}"',
|
|
instances_block,
|
|
)
|
|
block_text = (
|
|
block_text[:instances_pos]
|
|
+ updated_instances
|
|
+ block_text[instances_end + 1 :]
|
|
)
|
|
if field_positions is not None:
|
|
for field_name, pos in field_positions.items():
|
|
x = pos.get("x", 0)
|
|
y = pos.get("y", 0)
|
|
angle = pos.get("angle", 0)
|
|
block_text = re.sub(
|
|
r'(\(property\s+"'
|
|
+ re.escape(field_name)
|
|
+ r'"\s+"[^"]*"\s+)\(at\s+[\d\.\-]+\s+[\d\.\-]+\s+[\d\.\-]+\s*\)',
|
|
rf"\1(at {x} {y} {angle})",
|
|
block_text,
|
|
)
|
|
justify = pos.get("justify")
|
|
if justify is not None:
|
|
block_text = self._set_justify_on_property(
|
|
block_text, field_name, str(justify)
|
|
)
|
|
|
|
properties_added: Dict[str, Any] = {}
|
|
properties_updated: Dict[str, Any] = {}
|
|
if properties:
|
|
if not isinstance(properties, dict):
|
|
return {
|
|
"success": False,
|
|
"message": "properties must be a dict mapping property name -> value or spec",
|
|
}
|
|
for name, spec in properties.items():
|
|
if not isinstance(name, str) or not name:
|
|
return {
|
|
"success": False,
|
|
"message": f"Invalid property name: {name!r}",
|
|
}
|
|
# Normalise scalar values to a spec dict with just {"value": ...}
|
|
if not isinstance(spec, dict):
|
|
spec = {"value": spec}
|
|
try:
|
|
block_text, action = self._set_property_in_block(
|
|
block_text, name, spec, comp_origin
|
|
)
|
|
except ValueError as ve:
|
|
return {"success": False, "message": str(ve)}
|
|
target = properties_added if action == "added" else properties_updated
|
|
target[name] = spec.get("value")
|
|
|
|
properties_removed: list = []
|
|
if remove_properties:
|
|
if not isinstance(remove_properties, list):
|
|
return {
|
|
"success": False,
|
|
"message": "removeProperties must be a list of property names",
|
|
}
|
|
for name in remove_properties:
|
|
block_text, removed = self._remove_property_from_block(block_text, name)
|
|
if removed:
|
|
properties_removed.append(name)
|
|
|
|
content = content[:block_start] + block_text + content[block_end + 1 :]
|
|
|
|
with open(sch_file, "w", encoding="utf-8") as f:
|
|
f.write(content)
|
|
|
|
changes: Dict[str, Any] = {
|
|
k: v
|
|
for k, v in {
|
|
"footprint": new_footprint,
|
|
"value": new_value,
|
|
"reference": new_reference,
|
|
}.items()
|
|
if v is not None
|
|
}
|
|
if field_positions is not None:
|
|
changes["fieldPositions"] = field_positions
|
|
if properties_added:
|
|
changes["propertiesAdded"] = properties_added
|
|
if properties_updated:
|
|
changes["propertiesUpdated"] = properties_updated
|
|
if properties_removed:
|
|
changes["propertiesRemoved"] = properties_removed
|
|
|
|
logger.info(f"Edited schematic component {reference}: {changes}")
|
|
return {"success": True, "reference": reference, "updated": changes}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error editing schematic component: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_set_schematic_component_property(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add or update a single property on a placed schematic symbol.
|
|
|
|
Convenience wrapper around `edit_schematic_component` for the very common
|
|
case of setting one BOM/sourcing field at a time. The property is created
|
|
if it does not already exist, otherwise its value (and optionally its
|
|
position / visibility) is updated in place.
|
|
"""
|
|
logger.info("Setting schematic component property")
|
|
name = params.get("name")
|
|
if not isinstance(name, str) or not name:
|
|
return {"success": False, "message": "name is required"}
|
|
if "value" not in params:
|
|
return {"success": False, "message": "value is required"}
|
|
|
|
spec: Dict[str, Any] = {"value": params["value"]}
|
|
for key in ("x", "y", "angle", "hide", "fontSize", "justify"):
|
|
if params.get(key) is not None:
|
|
spec[key] = params[key]
|
|
|
|
return self._handle_edit_schematic_component(
|
|
{
|
|
"schematicPath": params.get("schematicPath"),
|
|
"reference": params.get("reference"),
|
|
"properties": {name: spec},
|
|
}
|
|
)
|
|
|
|
def _handle_remove_schematic_component_property(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Remove a single custom property from a placed schematic symbol.
|
|
|
|
Built-in fields (Reference, Value, Footprint, Datasheet) cannot be
|
|
removed — use `edit_schematic_component` to clear them instead.
|
|
"""
|
|
logger.info("Removing schematic component property")
|
|
name = params.get("name")
|
|
if not isinstance(name, str) or not name:
|
|
return {"success": False, "message": "name is required"}
|
|
return self._handle_edit_schematic_component(
|
|
{
|
|
"schematicPath": params.get("schematicPath"),
|
|
"reference": params.get("reference"),
|
|
"removeProperties": [name],
|
|
}
|
|
)
|
|
|
|
def _handle_get_schematic_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Return full component info: position and all field values with their (at x y angle) positions."""
|
|
logger.info("Getting schematic component info")
|
|
try:
|
|
import re
|
|
from pathlib import Path
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
reference = params.get("reference")
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
if not reference:
|
|
return {"success": False, "message": "reference is required"}
|
|
|
|
sch_file = Path(schematic_path)
|
|
if not sch_file.exists():
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
with open(sch_file, "r", encoding="utf-8") as f:
|
|
content = f.read()
|
|
|
|
# String-aware paren matcher (see _find_matching_paren): a naive
|
|
# counter over-runs on unescaped parens inside quoted strings (e.g.
|
|
# MCU pin names like "PA13(JTMS"), which would extend lib_symbols to
|
|
# EOF and make every placed-symbol lookup fail.
|
|
find_matching_paren = self._find_matching_paren
|
|
|
|
# Skip lib_symbols section
|
|
lib_sym_pos = content.find("(lib_symbols")
|
|
lib_sym_end = find_matching_paren(content, lib_sym_pos) if lib_sym_pos >= 0 else -1
|
|
|
|
# Find the placed symbol block for this reference. KiCAD may emit
|
|
# the children of (symbol ...) in different orders — most commonly
|
|
# `(symbol (lib_id "..."))`, but symbols whose library entry has
|
|
# been rescued / customised carry an extra `(lib_name "...")` first
|
|
# (`(symbol (lib_name "...") (lib_id "..."))`). Match `(symbol\s+(`
|
|
# — any opening paren — to handle both. The lib_symbols range check
|
|
# below excludes library-definition symbols, which use the
|
|
# `(symbol "name" ...)` form (quoted string, not paren).
|
|
block_start = block_end = None
|
|
search_start = 0
|
|
pattern = re.compile(r"\(symbol\s+\(")
|
|
while True:
|
|
m = pattern.search(content, search_start)
|
|
if not m:
|
|
break
|
|
pos = m.start()
|
|
if lib_sym_pos >= 0 and lib_sym_pos <= pos <= lib_sym_end:
|
|
search_start = lib_sym_end + 1
|
|
continue
|
|
end = find_matching_paren(content, pos)
|
|
if end < 0:
|
|
search_start = pos + 1
|
|
continue
|
|
block_text = content[pos : end + 1]
|
|
if re.search(
|
|
r'\(property\s+"Reference"\s+"' + re.escape(reference) + r'"',
|
|
block_text,
|
|
):
|
|
block_start, block_end = pos, end
|
|
break
|
|
search_start = end + 1
|
|
|
|
if block_start is None or block_end is None:
|
|
return {
|
|
"success": False,
|
|
"message": f"Component '{reference}' not found in schematic",
|
|
}
|
|
|
|
block_text = content[block_start : block_end + 1]
|
|
|
|
# Extract component position: the first (at x y angle) inside the
|
|
# symbol block. KiCAD always writes the symbol's own (at) before
|
|
# any (property ...) child blocks, so the first match is the
|
|
# symbol origin regardless of the (lib_name)/(lib_id) ordering.
|
|
comp_at = re.search(
|
|
r"\(at\s+([\d\.\-]+)\s+([\d\.\-]+)\s+([\d\.\-]+)\s*\)",
|
|
block_text,
|
|
)
|
|
if comp_at:
|
|
comp_pos = {
|
|
"x": float(comp_at.group(1)),
|
|
"y": float(comp_at.group(2)),
|
|
"angle": float(comp_at.group(3)),
|
|
}
|
|
else:
|
|
comp_pos = None
|
|
|
|
# Extract all properties with their at positions
|
|
prop_pattern = re.compile(
|
|
r'\(property\s+"([^"]*)"\s+"([^"]*)"\s+\(at\s+([\d\.\-]+)\s+([\d\.\-]+)\s+([\d\.\-]+)\s*\)'
|
|
)
|
|
fields = {}
|
|
for m in prop_pattern.finditer(block_text):
|
|
name, value, x, y, angle = (
|
|
m.group(1),
|
|
m.group(2),
|
|
m.group(3),
|
|
m.group(4),
|
|
m.group(5),
|
|
)
|
|
fields[name] = {
|
|
"value": value,
|
|
"x": float(x),
|
|
"y": float(y),
|
|
"angle": float(angle),
|
|
}
|
|
|
|
return {
|
|
"success": True,
|
|
"reference": reference,
|
|
"position": comp_pos,
|
|
"fields": fields,
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error getting schematic component: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_add_schematic_wire(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a wire to a schematic using WireManager, with optional pin snapping"""
|
|
logger.info("Adding wire to schematic")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.wire_manager import WireManager
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
points = params.get("waypoints")
|
|
properties = params.get("properties", {})
|
|
snap_to_pins = params.get("snapToPins", True)
|
|
snap_tolerance = params.get("snapTolerance", 1.0)
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "Schematic path is required"}
|
|
if not points or len(points) < 2:
|
|
return {
|
|
"success": False,
|
|
"message": "At least 2 waypoints are required",
|
|
}
|
|
|
|
# Make a mutable copy of points
|
|
points = [list(p) for p in points]
|
|
|
|
# Pin snapping: adjust first and last endpoints to nearest pin
|
|
snapped_info = []
|
|
if snap_to_pins:
|
|
from commands.pin_locator import PinLocator
|
|
|
|
locator = PinLocator()
|
|
sch_path = Path(schematic_path)
|
|
|
|
# Load schematic to iterate all symbols
|
|
from skip import Schematic as SkipSchematic
|
|
|
|
sch = SkipSchematic(str(sch_path))
|
|
|
|
# Collect all pin locations: list of (ref, pin_num, [x, y])
|
|
all_pins = []
|
|
for symbol in sch.symbol:
|
|
if not hasattr(symbol.property, "Reference"):
|
|
continue
|
|
ref = symbol.property.Reference.value
|
|
if ref.startswith("_TEMPLATE"):
|
|
continue
|
|
pin_locs = locator.get_all_symbol_pins(sch_path, ref)
|
|
for pin_num, coords in pin_locs.items():
|
|
all_pins.append((ref, pin_num, coords))
|
|
|
|
def find_nearest_pin(point: Any, tolerance: Any) -> Any:
|
|
"""Find the nearest pin within tolerance of a point."""
|
|
best = None
|
|
best_dist = tolerance
|
|
for ref, pin_num, coords in all_pins:
|
|
dx = point[0] - coords[0]
|
|
dy = point[1] - coords[1]
|
|
dist = (dx * dx + dy * dy) ** 0.5
|
|
if dist <= best_dist:
|
|
best_dist = dist
|
|
best = (ref, pin_num, coords)
|
|
return best
|
|
|
|
# Snap first endpoint
|
|
match = find_nearest_pin(points[0], snap_tolerance)
|
|
if match:
|
|
ref, pin_num, coords = match
|
|
logger.info(
|
|
f"Snapped start point {points[0]} -> {coords} (pin {ref}/{pin_num})"
|
|
)
|
|
snapped_info.append(
|
|
f"start snapped to {ref}/{pin_num} at [{coords[0]}, {coords[1]}]"
|
|
)
|
|
points[0] = list(coords)
|
|
|
|
# Snap last endpoint
|
|
match = find_nearest_pin(points[-1], snap_tolerance)
|
|
if match:
|
|
ref, pin_num, coords = match
|
|
logger.info(f"Snapped end point {points[-1]} -> {coords} (pin {ref}/{pin_num})")
|
|
snapped_info.append(
|
|
f"end snapped to {ref}/{pin_num} at [{coords[0]}, {coords[1]}]"
|
|
)
|
|
points[-1] = list(coords)
|
|
|
|
# Extract wire properties
|
|
stroke_width = properties.get("stroke_width", 0)
|
|
stroke_type = properties.get("stroke_type", "default")
|
|
|
|
# Use WireManager for S-expression manipulation
|
|
if len(points) == 2:
|
|
success = WireManager.add_wire(
|
|
Path(schematic_path),
|
|
points[0],
|
|
points[1],
|
|
stroke_width=stroke_width,
|
|
stroke_type=stroke_type,
|
|
)
|
|
else:
|
|
success = WireManager.add_polyline_wire(
|
|
Path(schematic_path),
|
|
points,
|
|
stroke_width=stroke_width,
|
|
stroke_type=stroke_type,
|
|
)
|
|
|
|
if success:
|
|
message = "Wire added successfully"
|
|
if snapped_info:
|
|
message += "; " + "; ".join(snapped_info)
|
|
return {"success": True, "message": message}
|
|
else:
|
|
return {"success": False, "message": "Failed to add wire"}
|
|
except Exception as e:
|
|
logger.error(f"Error adding wire to schematic: {str(e)}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {
|
|
"success": False,
|
|
"message": str(e),
|
|
"errorDetails": traceback.format_exc(),
|
|
}
|
|
|
|
def _handle_list_schematic_libraries(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List available symbol libraries"""
|
|
logger.info("Listing schematic libraries")
|
|
try:
|
|
search_paths = params.get("searchPaths")
|
|
|
|
libraries = SchematicLibraryManager.list_available_libraries(search_paths)
|
|
return {"success": True, "libraries": libraries}
|
|
except Exception as e:
|
|
logger.error(f"Error listing schematic libraries: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_find_unconnected_pins(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List component pins with no wire/label/power symbol touching them"""
|
|
logger.info("Finding unconnected pins")
|
|
try:
|
|
from commands.schematic_analysis import find_unconnected_pins
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
result = find_unconnected_pins(schematic_path)
|
|
return {"success": True, **result}
|
|
except ImportError:
|
|
return {
|
|
"success": False,
|
|
"message": "schematic_analysis module not available",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error finding unconnected pins: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_check_wire_collisions(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Detect wires passing through component bodies without connecting to pins"""
|
|
logger.info("Checking wire collisions")
|
|
try:
|
|
from commands.schematic_analysis import check_wire_collisions
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
result = check_wire_collisions(schematic_path)
|
|
return {"success": True, **result}
|
|
except ImportError:
|
|
return {
|
|
"success": False,
|
|
"message": "schematic_analysis module not available",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error checking wire collisions: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
# ------------------------------------------------------------------ #
|
|
# Footprint handlers #
|
|
# ------------------------------------------------------------------ #
|
|
|
|
def _handle_create_footprint(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Create a new .kicad_mod footprint file in a .pretty library."""
|
|
logger.info(f"create_footprint: {params.get('name')} in {params.get('libraryPath')}")
|
|
try:
|
|
creator = FootprintCreator()
|
|
return creator.create_footprint(
|
|
library_path=params.get("libraryPath", ""),
|
|
name=params.get("name", ""),
|
|
description=params.get("description", ""),
|
|
tags=params.get("tags", ""),
|
|
pads=params.get("pads", []),
|
|
courtyard=params.get("courtyard"),
|
|
silkscreen=params.get("silkscreen"),
|
|
fab_layer=params.get("fabLayer"),
|
|
ref_position=params.get("refPosition"),
|
|
value_position=params.get("valuePosition"),
|
|
overwrite=params.get("overwrite", False),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"create_footprint error: {e}")
|
|
return {"success": False, "error": str(e)}
|
|
|
|
def _handle_edit_footprint_pad(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Edit an existing pad in a .kicad_mod file."""
|
|
logger.info(
|
|
f"edit_footprint_pad: pad {params.get('padNumber')} in {params.get('footprintPath')}"
|
|
)
|
|
try:
|
|
creator = FootprintCreator()
|
|
return creator.edit_footprint_pad(
|
|
footprint_path=params.get("footprintPath", ""),
|
|
pad_number=str(params.get("padNumber", "1")),
|
|
size=params.get("size"),
|
|
at=params.get("at"),
|
|
drill=params.get("drill"),
|
|
shape=params.get("shape"),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"edit_footprint_pad error: {e}")
|
|
return {"success": False, "error": str(e)}
|
|
|
|
def _handle_list_footprint_libraries(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List .pretty footprint libraries and their contents."""
|
|
logger.info("list_footprint_libraries")
|
|
try:
|
|
creator = FootprintCreator()
|
|
return creator.list_footprint_libraries(search_paths=params.get("searchPaths"))
|
|
except Exception as e:
|
|
logger.error(f"list_footprint_libraries error: {e}")
|
|
return {"success": False, "error": str(e)}
|
|
|
|
def _handle_register_footprint_library(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Register a .pretty library in KiCAD's fp-lib-table."""
|
|
logger.info(f"register_footprint_library: {params.get('libraryPath')}")
|
|
try:
|
|
creator = FootprintCreator()
|
|
return creator.register_footprint_library(
|
|
library_path=params.get("libraryPath", ""),
|
|
library_name=params.get("libraryName"),
|
|
description=params.get("description", ""),
|
|
scope=params.get("scope", "project"),
|
|
project_path=params.get("projectPath"),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"register_footprint_library error: {e}")
|
|
return {"success": False, "error": str(e)}
|
|
|
|
# ------------------------------------------------------------------ #
|
|
# Symbol creator handlers #
|
|
# ------------------------------------------------------------------ #
|
|
|
|
def _handle_create_symbol(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Create a new symbol in a .kicad_sym library."""
|
|
logger.info(f"create_symbol: {params.get('name')} in {params.get('libraryPath')}")
|
|
try:
|
|
creator = SymbolCreator()
|
|
return creator.create_symbol(
|
|
library_path=params.get("libraryPath", ""),
|
|
name=params.get("name", ""),
|
|
reference_prefix=params.get("referencePrefix", "U"),
|
|
description=params.get("description", ""),
|
|
keywords=params.get("keywords", ""),
|
|
datasheet=params.get("datasheet", "~"),
|
|
footprint=params.get("footprint", ""),
|
|
in_bom=params.get("inBom", True),
|
|
on_board=params.get("onBoard", True),
|
|
pins=params.get("pins", []),
|
|
rectangles=params.get("rectangles", []),
|
|
polylines=params.get("polylines", []),
|
|
overwrite=params.get("overwrite", False),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"create_symbol error: {e}")
|
|
return {"success": False, "error": str(e)}
|
|
|
|
def _handle_delete_symbol(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Delete a symbol from a .kicad_sym library."""
|
|
logger.info(f"delete_symbol: {params.get('name')} from {params.get('libraryPath')}")
|
|
try:
|
|
creator = SymbolCreator()
|
|
return creator.delete_symbol(
|
|
library_path=params.get("libraryPath", ""),
|
|
name=params.get("name", ""),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"delete_symbol error: {e}")
|
|
return {"success": False, "error": str(e)}
|
|
|
|
def _handle_list_symbols_in_library(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List all symbols in a .kicad_sym file."""
|
|
logger.info(f"list_symbols_in_library: {params.get('libraryPath')}")
|
|
try:
|
|
creator = SymbolCreator()
|
|
return creator.list_symbols(
|
|
library_path=params.get("libraryPath", ""),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"list_symbols_in_library error: {e}")
|
|
return {"success": False, "error": str(e)}
|
|
|
|
def _handle_register_symbol_library(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Register a .kicad_sym library in KiCAD's sym-lib-table."""
|
|
logger.info(f"register_symbol_library: {params.get('libraryPath')}")
|
|
try:
|
|
creator = SymbolCreator()
|
|
return creator.register_symbol_library(
|
|
library_path=params.get("libraryPath", ""),
|
|
library_name=params.get("libraryName"),
|
|
description=params.get("description", ""),
|
|
scope=params.get("scope", "project"),
|
|
project_path=params.get("projectPath"),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"register_symbol_library error: {e}")
|
|
return {"success": False, "error": str(e)}
|
|
|
|
def _handle_export_schematic_pdf(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Export schematic to PDF"""
|
|
logger.info("Exporting schematic to PDF")
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
output_path = params.get("outputPath")
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "Schematic path is required"}
|
|
if not output_path:
|
|
return {"success": False, "message": "Output path is required"}
|
|
|
|
if not os.path.exists(schematic_path):
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
import subprocess
|
|
|
|
cmd = [
|
|
"kicad-cli",
|
|
"sch",
|
|
"export",
|
|
"pdf",
|
|
"--output",
|
|
output_path,
|
|
schematic_path,
|
|
]
|
|
|
|
if params.get("blackAndWhite"):
|
|
cmd.insert(-1, "--black-and-white")
|
|
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
|
|
|
if result.returncode == 0:
|
|
return {"success": True, "file": {"path": output_path}}
|
|
else:
|
|
return {
|
|
"success": False,
|
|
"message": f"kicad-cli failed: {result.stderr}",
|
|
}
|
|
|
|
except FileNotFoundError:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
except Exception as e:
|
|
logger.error(f"Error exporting schematic to PDF: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_add_schematic_net_label(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a net label to schematic using WireManager.
|
|
|
|
When componentRef and pinNumber are supplied the label is placed at the
|
|
exact pin endpoint retrieved via PinLocator, ignoring the provided
|
|
position. The response includes the actual coordinates used and
|
|
whether the label landed on a pin endpoint.
|
|
"""
|
|
logger.info("Adding net label to schematic")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.wire_manager import WireManager
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
net_name = params.get("netName")
|
|
position = params.get("position")
|
|
label_type = params.get("labelType", "label")
|
|
orientation = params.get("orientation", 0)
|
|
component_ref = params.get("componentRef")
|
|
pin_number = params.get("pinNumber")
|
|
|
|
if not all([schematic_path, net_name]):
|
|
return {
|
|
"success": False,
|
|
"message": "Missing required parameters: schematicPath, netName",
|
|
}
|
|
|
|
snapped_to_pin: Optional[Dict[str, Any]] = None
|
|
|
|
if component_ref and pin_number:
|
|
# Snap position to exact pin endpoint using PinLocator
|
|
from commands.pin_locator import PinLocator
|
|
|
|
locator = PinLocator()
|
|
pin_loc = locator.get_pin_location(
|
|
Path(schematic_path), component_ref, str(pin_number)
|
|
)
|
|
if pin_loc is None:
|
|
return {
|
|
"success": False,
|
|
"message": (
|
|
f"Could not locate pin {pin_number} on {component_ref}. "
|
|
"Check the reference and pin number."
|
|
),
|
|
}
|
|
position = pin_loc
|
|
snapped_to_pin = {"component": component_ref, "pin": str(pin_number)}
|
|
logger.info(
|
|
f"Snapped label '{net_name}' to pin {component_ref}/{pin_number} at {position}"
|
|
)
|
|
elif position is None:
|
|
return {
|
|
"success": False,
|
|
"message": (
|
|
"Missing position. Either provide position [x, y] or "
|
|
"componentRef + pinNumber to snap to a pin endpoint."
|
|
),
|
|
}
|
|
|
|
# Collect existing net names BEFORE adding the new label so we can
|
|
# detect case-mismatch collisions against pre-existing nets only.
|
|
existing_net_names: List[str] = []
|
|
try:
|
|
pre_schematic = SchematicManager.load_schematic(schematic_path)
|
|
if pre_schematic is not None:
|
|
if hasattr(pre_schematic, "label"):
|
|
for lbl in pre_schematic.label:
|
|
if hasattr(lbl, "value"):
|
|
existing_net_names.append(lbl.value)
|
|
if hasattr(pre_schematic, "global_label"):
|
|
for lbl in pre_schematic.global_label:
|
|
if hasattr(lbl, "value"):
|
|
existing_net_names.append(lbl.value)
|
|
except Exception:
|
|
# Non-fatal: if we can't read existing nets, skip the warning
|
|
existing_net_names = []
|
|
|
|
# Use WireManager for S-expression manipulation
|
|
success = WireManager.add_label(
|
|
Path(schematic_path),
|
|
net_name,
|
|
position,
|
|
label_type=label_type,
|
|
orientation=orientation,
|
|
)
|
|
|
|
if not success:
|
|
return {"success": False, "message": "Failed to add net label"}
|
|
|
|
# Compute case-mismatch warnings against pre-existing net names.
|
|
# A collision is: existing name != new name, but lowercases match.
|
|
new_name_lower = net_name.lower()
|
|
case_warnings: List[str] = [
|
|
f"Net '{existing}' already exists — label '{net_name}' may be a case mismatch."
|
|
for existing in existing_net_names
|
|
if existing.lower() == new_name_lower and existing != net_name
|
|
]
|
|
|
|
response: Dict[str, Any] = {
|
|
"success": True,
|
|
"message": f"Added net label '{net_name}' at {position}",
|
|
"actual_position": position,
|
|
}
|
|
if snapped_to_pin:
|
|
response["snapped_to_pin"] = snapped_to_pin
|
|
response["message"] = (
|
|
f"Added net label '{net_name}' at exact pin endpoint "
|
|
f"{component_ref}/{pin_number} ({position[0]}, {position[1]})"
|
|
)
|
|
if case_warnings:
|
|
response["case_warnings"] = case_warnings
|
|
return response
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error adding net label: {str(e)}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {
|
|
"success": False,
|
|
"message": str(e),
|
|
"errorDetails": traceback.format_exc(),
|
|
}
|
|
|
|
def _handle_add_no_connect(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a no-connect flag (X marker) to an unconnected pin in the schematic."""
|
|
logger.info("Adding no-connect flag to schematic")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.pin_locator import PinLocator
|
|
from commands.wire_manager import WireManager
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
position = params.get("position")
|
|
component_ref = params.get("componentRef")
|
|
pin_number = params.get("pinNumber")
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
# Snap to pin endpoint when componentRef + pinNumber are provided
|
|
snapped_to_pin = None
|
|
if component_ref and pin_number is not None:
|
|
locator = PinLocator()
|
|
pin_loc = locator.get_pin_location(
|
|
Path(schematic_path), component_ref, str(pin_number)
|
|
)
|
|
if pin_loc is None:
|
|
return {
|
|
"success": False,
|
|
"message": f"Could not locate pin {pin_number} on {component_ref}",
|
|
}
|
|
position = pin_loc
|
|
snapped_to_pin = {"component": component_ref, "pin": str(pin_number)}
|
|
elif position is None:
|
|
return {
|
|
"success": False,
|
|
"message": "Provide either position [x, y] or componentRef + pinNumber",
|
|
}
|
|
|
|
success = WireManager.add_no_connect(Path(schematic_path), position)
|
|
if success:
|
|
result = {
|
|
"success": True,
|
|
"message": f"Added no-connect flag at {position}",
|
|
"actual_position": position,
|
|
}
|
|
if snapped_to_pin:
|
|
result["snapped_to_pin"] = snapped_to_pin
|
|
return result
|
|
else:
|
|
return {"success": False, "message": "Failed to add no-connect flag"}
|
|
|
|
except Exception as e:
|
|
import traceback
|
|
|
|
logger.error(f"Error adding no-connect: {e}")
|
|
return {
|
|
"success": False,
|
|
"message": str(e),
|
|
"errorDetails": traceback.format_exc(),
|
|
}
|
|
|
|
def _handle_connect_to_net(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Connect a component pin to a named net using wire stub and label,
|
|
and also assign the net to the corresponding pad on the PCB board so
|
|
that save_project persists the net (pcbnew.SaveBoard only writes nets
|
|
that are referenced by at least one board element).
|
|
"""
|
|
logger.info("Connecting component pin to net")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
component_ref = params.get("componentRef")
|
|
pin_name = params.get("pinName")
|
|
net_name = params.get("netName")
|
|
|
|
if not all([schematic_path, component_ref, pin_name, net_name]):
|
|
return {"success": False, "message": "Missing required parameters"}
|
|
|
|
# Use ConnectionManager with new WireManager integration
|
|
result = ConnectionManager.connect_to_net(
|
|
Path(schematic_path), component_ref, pin_name, net_name
|
|
)
|
|
|
|
# Also assign the net to the pad on the PCB board
|
|
if self.board and isinstance(result, dict) and result.get("success"):
|
|
try:
|
|
if self._assign_net_to_pad(component_ref, pin_name, net_name):
|
|
msg = result.get("message", "")
|
|
result["message"] = (msg + " (PCB pad also updated)").strip()
|
|
except Exception as pcb_err:
|
|
logger.warning(f"Could not assign net to PCB pad: {pcb_err}")
|
|
|
|
return result
|
|
except Exception as e:
|
|
logger.error(f"Error connecting to net: {str(e)}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {
|
|
"success": False,
|
|
"message": str(e),
|
|
"errorDetails": traceback.format_exc(),
|
|
}
|
|
|
|
def _handle_connect_passthrough(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Connect all pins of source connector to matching pins of target connector"""
|
|
logger.info("Connecting passthrough between two connectors")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
source_ref = params.get("sourceRef")
|
|
target_ref = params.get("targetRef")
|
|
net_prefix = params.get("netPrefix", "PIN")
|
|
pin_offset = int(params.get("pinOffset", 0))
|
|
|
|
if not all([schematic_path, source_ref, target_ref]):
|
|
return {
|
|
"success": False,
|
|
"message": "Missing required parameters: schematicPath, sourceRef, targetRef",
|
|
}
|
|
|
|
result = ConnectionManager.connect_passthrough(
|
|
Path(schematic_path), source_ref, target_ref, net_prefix, pin_offset
|
|
)
|
|
|
|
# Also assign nets to PCB pads for each successfully connected pin
|
|
pcb_assigned = 0
|
|
if self.board:
|
|
import re as _re
|
|
|
|
for conn_info in result.get("connected", []):
|
|
# Expected format: "{src_ref}/{pin} <-> {tgt_ref}/{pin} [{net}]"
|
|
try:
|
|
parts = conn_info.split(" <-> ")
|
|
if len(parts) != 2:
|
|
continue
|
|
src_part = parts[0]
|
|
rest = parts[1]
|
|
bracket_match = _re.search(r"\[(.+)\]", rest)
|
|
tgt_part = rest.split(" [")[0] if " [" in rest else rest
|
|
net_name = bracket_match.group(1) if bracket_match else None
|
|
if not net_name:
|
|
continue
|
|
|
|
src_ref_pin = src_part.split("/")
|
|
tgt_ref_pin = tgt_part.split("/")
|
|
if len(src_ref_pin) == 2 and self._assign_net_to_pad(
|
|
src_ref_pin[0], src_ref_pin[1], net_name
|
|
):
|
|
pcb_assigned += 1
|
|
if len(tgt_ref_pin) == 2 and self._assign_net_to_pad(
|
|
tgt_ref_pin[0], tgt_ref_pin[1], net_name
|
|
):
|
|
pcb_assigned += 1
|
|
except Exception as parse_err:
|
|
logger.debug(
|
|
f"Could not parse passthrough result for PCB assignment: {parse_err}"
|
|
)
|
|
|
|
n_ok = len(result["connected"])
|
|
n_fail = len(result["failed"])
|
|
msg = f"Passthrough complete: {n_ok} connected, {n_fail} failed"
|
|
if pcb_assigned:
|
|
msg += f" ({pcb_assigned} PCB pads updated)"
|
|
return {
|
|
"success": n_fail == 0,
|
|
"message": msg,
|
|
"connected": result["connected"],
|
|
"failed": result["failed"],
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error in connect_passthrough: {str(e)}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _assign_net_to_pad(self, component_ref: str, pin_name: str, net_name: str) -> bool:
|
|
"""Assign a net to a specific pad on the PCB board.
|
|
|
|
Ensures the net exists on the board and sets it on the matching pad.
|
|
Needed because pcbnew.SaveBoard() drops nets that are not referenced
|
|
by any board element (pad/track/via/zone).
|
|
Returns True if the pad was found and updated.
|
|
"""
|
|
board = self.board
|
|
if not board:
|
|
return False
|
|
|
|
netinfo = board.GetNetInfo()
|
|
nets_map = netinfo.NetsByName()
|
|
if not nets_map.has_key(net_name):
|
|
net_item = pcbnew.NETINFO_ITEM(board, net_name)
|
|
board.Add(net_item)
|
|
netinfo = board.GetNetInfo()
|
|
nets_map = netinfo.NetsByName()
|
|
|
|
if not nets_map.has_key(net_name):
|
|
logger.warning(f"Net '{net_name}' could not be created on board")
|
|
return False
|
|
|
|
net_obj = nets_map[net_name]
|
|
|
|
for fp in board.GetFootprints():
|
|
if fp.GetReference() == component_ref:
|
|
for pad in fp.Pads():
|
|
if str(pad.GetNumber()) == str(pin_name):
|
|
pad.SetNet(net_obj)
|
|
logger.info(
|
|
f"Assigned net '{net_name}' to pad {component_ref}/{pin_name} on PCB"
|
|
)
|
|
return True
|
|
logger.warning(f"Pad '{pin_name}' not found on footprint '{component_ref}'")
|
|
return False
|
|
|
|
logger.warning(f"Footprint '{component_ref}' not found on board")
|
|
return False
|
|
|
|
def _handle_get_schematic_pin_locations(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Return exact pin endpoint coordinates for a schematic component"""
|
|
logger.info("Getting schematic pin locations")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.pin_locator import PinLocator
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
reference = params.get("reference")
|
|
|
|
if not all([schematic_path, reference]):
|
|
return {
|
|
"success": False,
|
|
"message": "Missing required parameters: schematicPath, reference",
|
|
}
|
|
|
|
locator = PinLocator()
|
|
all_pins = locator.get_all_symbol_pins(Path(schematic_path), reference)
|
|
|
|
if not all_pins:
|
|
return {
|
|
"success": False,
|
|
"message": f"No pins found for {reference} — check reference and schematic path",
|
|
}
|
|
|
|
# Enrich with pin names and angles from the symbol definition
|
|
pins_def = (
|
|
locator.get_symbol_pins(
|
|
Path(schematic_path),
|
|
locator._get_lib_id(Path(schematic_path), reference),
|
|
)
|
|
if hasattr(locator, "_get_lib_id")
|
|
else {}
|
|
)
|
|
|
|
result = {}
|
|
for pin_num, coords in all_pins.items():
|
|
entry = {"x": coords[0], "y": coords[1]}
|
|
if pin_num in pins_def:
|
|
entry["name"] = pins_def[pin_num].get("name", pin_num)
|
|
entry["angle"] = (
|
|
locator.get_pin_angle(Path(schematic_path), reference, pin_num) or 0
|
|
)
|
|
result[pin_num] = entry
|
|
|
|
return {"success": True, "reference": reference, "pins": result}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error getting pin locations: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_get_schematic_view(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Get a rasterised image of the schematic (SVG export → optional PNG conversion)"""
|
|
logger.info("Getting schematic view")
|
|
import base64
|
|
import subprocess
|
|
import tempfile
|
|
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path or not os.path.exists(schematic_path):
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
fmt = params.get("format", "png")
|
|
width = params.get("width", 1200)
|
|
height = params.get("height", 900)
|
|
|
|
# Step 1: Export schematic to SVG via kicad-cli
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
svg_path = os.path.join(tmpdir, "schematic.svg")
|
|
cmd = [
|
|
"kicad-cli",
|
|
"sch",
|
|
"export",
|
|
"svg",
|
|
"--output",
|
|
tmpdir,
|
|
"--no-background-color",
|
|
schematic_path,
|
|
]
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
|
|
|
if result.returncode != 0:
|
|
return {
|
|
"success": False,
|
|
"message": f"kicad-cli SVG export failed: {result.stderr}",
|
|
}
|
|
|
|
# kicad-cli may name the file after the schematic, find it
|
|
import glob
|
|
|
|
svg_files = glob.glob(os.path.join(tmpdir, "*.svg"))
|
|
if not svg_files:
|
|
return {
|
|
"success": False,
|
|
"message": "No SVG file produced by kicad-cli",
|
|
}
|
|
svg_path = svg_files[0]
|
|
|
|
if fmt == "svg":
|
|
with open(svg_path, "r", encoding="utf-8") as f:
|
|
svg_data = f.read()
|
|
return {"success": True, "imageData": svg_data, "format": "svg"}
|
|
|
|
# Step 2: Convert SVG to PNG (cffi-free)
|
|
png_data = _svg_to_png(svg_path, width, height)
|
|
if png_data is None:
|
|
with open(svg_path, "r", encoding="utf-8") as f:
|
|
svg_data = f.read()
|
|
return {
|
|
"success": True,
|
|
"imageData": svg_data,
|
|
"format": "svg",
|
|
"message": "No PNG converter available — returning SVG. Install pymupdf, inkscape, or imagemagick.",
|
|
}
|
|
|
|
return {
|
|
"success": True,
|
|
"imageData": base64.b64encode(png_data).decode("utf-8"),
|
|
"format": "png",
|
|
"width": width,
|
|
"height": height,
|
|
}
|
|
|
|
except FileNotFoundError:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
except Exception as e:
|
|
logger.error(f"Error getting schematic view: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_list_schematic_components(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List all components in a schematic"""
|
|
logger.info("Listing schematic components")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.pin_locator import PinLocator
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
sch_file = Path(schematic_path)
|
|
if not sch_file.exists():
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
# Optional filters
|
|
filter_params = params.get("filter", {})
|
|
lib_id_filter = filter_params.get("libId", "")
|
|
ref_prefix_filter = filter_params.get("referencePrefix", "")
|
|
|
|
locator = PinLocator()
|
|
components = []
|
|
|
|
for symbol in schematic.symbol:
|
|
if not hasattr(symbol.property, "Reference"):
|
|
continue
|
|
ref = symbol.property.Reference.value
|
|
# Skip template symbols
|
|
if ref.startswith("_TEMPLATE"):
|
|
continue
|
|
|
|
lib_id = symbol.lib_id.value if hasattr(symbol, "lib_id") else ""
|
|
|
|
# Apply filters
|
|
if lib_id_filter and lib_id_filter not in lib_id:
|
|
continue
|
|
if ref_prefix_filter and not ref.startswith(ref_prefix_filter):
|
|
continue
|
|
|
|
value = symbol.property.Value.value if hasattr(symbol.property, "Value") else ""
|
|
footprint = (
|
|
symbol.property.Footprint.value if hasattr(symbol.property, "Footprint") else ""
|
|
)
|
|
position = symbol.at.value if hasattr(symbol, "at") else [0, 0, 0]
|
|
uuid_val = symbol.uuid.value if hasattr(symbol, "uuid") else ""
|
|
|
|
comp = {
|
|
"reference": ref,
|
|
"libId": lib_id,
|
|
"value": value,
|
|
"footprint": footprint,
|
|
"position": {"x": float(position[0]), "y": float(position[1])},
|
|
"rotation": float(position[2]) if len(position) > 2 else 0,
|
|
"uuid": str(uuid_val),
|
|
}
|
|
|
|
# Get pins if available
|
|
try:
|
|
all_pins = locator.get_all_symbol_pins(sch_file, ref)
|
|
if all_pins:
|
|
pins_def = locator.get_symbol_pins(sch_file, lib_id) or {}
|
|
pin_list = []
|
|
for pin_num, coords in all_pins.items():
|
|
pin_info = {
|
|
"number": pin_num,
|
|
"position": {"x": coords[0], "y": coords[1]},
|
|
}
|
|
if pin_num in pins_def:
|
|
pin_info["name"] = pins_def[pin_num].get("name", pin_num)
|
|
pin_list.append(pin_info)
|
|
comp["pins"] = pin_list
|
|
except Exception:
|
|
pass # Pin lookup is best-effort
|
|
|
|
components.append(comp)
|
|
|
|
return {"success": True, "components": components, "count": len(components)}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error listing schematic components: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_list_schematic_nets(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List all nets in a schematic with their connections"""
|
|
logger.info("Listing schematic nets")
|
|
try:
|
|
from commands.wire_connectivity import (
|
|
_build_adjacency,
|
|
_discover_sub_sheets,
|
|
_load_sexp,
|
|
_parse_labels_sexp,
|
|
_parse_virtual_connections,
|
|
_parse_wires,
|
|
count_pins_on_net,
|
|
get_connections_for_net,
|
|
)
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
# Collect net names from the top-level sheet using sexpdata.
|
|
# Falls back to kicad-skip's label collections when the file
|
|
# cannot be read (e.g. mocked schematics in unit tests).
|
|
net_names: set = set()
|
|
sexp_loaded = False
|
|
try:
|
|
sexp = _load_sexp(schematic_path)
|
|
sexp_loaded = True
|
|
_, label_to_points = _parse_labels_sexp(sexp)
|
|
net_names.update(label_to_points.keys())
|
|
except Exception as e:
|
|
logger.debug(
|
|
f"Could not parse labels from {schematic_path} via sexp ({e}); "
|
|
"falling back to kicad-skip label collections"
|
|
)
|
|
for attr in ("label", "global_label"):
|
|
if not hasattr(schematic, attr):
|
|
continue
|
|
for label in getattr(schematic, attr):
|
|
if hasattr(label, "value"):
|
|
net_names.add(label.value)
|
|
|
|
# Collect net names from all sub-sheets (only when the parent
|
|
# sheet was readable; fake/mock paths skip recursion entirely).
|
|
if sexp_loaded:
|
|
sub_sheets = _discover_sub_sheets(schematic_path)
|
|
for sub_path in sub_sheets:
|
|
try:
|
|
sub_sexp = _load_sexp(sub_path)
|
|
_, sub_label_to_points = _parse_labels_sexp(sub_sexp)
|
|
net_names.update(sub_label_to_points.keys())
|
|
except Exception as e:
|
|
logger.warning(f"Error reading sub-sheet {sub_path}: {e}")
|
|
|
|
# Pre-build shared wire graph structures for efficiency
|
|
all_wires = _parse_wires(schematic)
|
|
if all_wires:
|
|
adjacency, iu_to_wires = _build_adjacency(all_wires)
|
|
else:
|
|
adjacency, iu_to_wires = [], {}
|
|
point_to_label, label_to_points = _parse_virtual_connections(schematic, schematic_path)
|
|
|
|
nets = []
|
|
for net_name in sorted(net_names):
|
|
connections = get_connections_for_net(schematic, schematic_path, net_name)
|
|
pin_count = count_pins_on_net(
|
|
schematic,
|
|
schematic_path,
|
|
net_name,
|
|
all_wires,
|
|
iu_to_wires,
|
|
adjacency,
|
|
point_to_label,
|
|
label_to_points,
|
|
)
|
|
nets.append(
|
|
{
|
|
"name": net_name,
|
|
"connections": connections,
|
|
"connected_pin_count": pin_count,
|
|
}
|
|
)
|
|
|
|
return {"success": True, "nets": nets, "count": len(nets)}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error listing schematic nets: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_list_schematic_wires(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List all wires in a schematic"""
|
|
logger.info("Listing schematic wires")
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
wires = []
|
|
if hasattr(schematic, "wire"):
|
|
for wire in schematic.wire:
|
|
if hasattr(wire, "pts") and hasattr(wire.pts, "xy"):
|
|
points = []
|
|
for point in wire.pts.xy:
|
|
if hasattr(point, "value"):
|
|
points.append(
|
|
{
|
|
"x": float(point.value[0]),
|
|
"y": float(point.value[1]),
|
|
}
|
|
)
|
|
|
|
if len(points) >= 2:
|
|
wires.append(
|
|
{
|
|
"start": points[0],
|
|
"end": points[-1],
|
|
}
|
|
)
|
|
|
|
return {"success": True, "wires": wires, "count": len(wires)}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error listing schematic wires: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_list_schematic_labels(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List all net labels and power flags in a schematic"""
|
|
logger.info("Listing schematic labels")
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
net_name = params.get("netName")
|
|
label_type = params.get("labelType")
|
|
|
|
_valid_label_types = {"net", "global", "power"}
|
|
if label_type is not None and label_type not in _valid_label_types:
|
|
return {"success": False, "message": "labelType must be one of: net, global, power"}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
labels = []
|
|
|
|
# Regular labels
|
|
if hasattr(schematic, "label"):
|
|
for label in schematic.label:
|
|
if hasattr(label, "value"):
|
|
pos = (
|
|
label.at.value
|
|
if hasattr(label, "at") and hasattr(label.at, "value")
|
|
else [0, 0]
|
|
)
|
|
labels.append(
|
|
{
|
|
"name": label.value,
|
|
"type": "net",
|
|
"position": {"x": float(pos[0]), "y": float(pos[1])},
|
|
}
|
|
)
|
|
|
|
# Global labels
|
|
if hasattr(schematic, "global_label"):
|
|
for label in schematic.global_label:
|
|
if hasattr(label, "value"):
|
|
pos = (
|
|
label.at.value
|
|
if hasattr(label, "at") and hasattr(label.at, "value")
|
|
else [0, 0]
|
|
)
|
|
labels.append(
|
|
{
|
|
"name": label.value,
|
|
"type": "global",
|
|
"position": {"x": float(pos[0]), "y": float(pos[1])},
|
|
}
|
|
)
|
|
|
|
# Power symbols (components with power flag)
|
|
if hasattr(schematic, "symbol"):
|
|
for symbol in schematic.symbol:
|
|
if not hasattr(symbol.property, "Reference"):
|
|
continue
|
|
ref = symbol.property.Reference.value
|
|
if ref.startswith("_TEMPLATE"):
|
|
continue
|
|
if not ref.startswith("#PWR"):
|
|
continue
|
|
value = (
|
|
symbol.property.Value.value if hasattr(symbol.property, "Value") else ref
|
|
)
|
|
pos = symbol.at.value if hasattr(symbol, "at") else [0, 0, 0]
|
|
labels.append(
|
|
{
|
|
"name": value,
|
|
"type": "power",
|
|
"position": {"x": float(pos[0]), "y": float(pos[1])},
|
|
}
|
|
)
|
|
|
|
# Apply filters
|
|
if net_name is not None:
|
|
labels = [lbl for lbl in labels if lbl["name"] == net_name]
|
|
if label_type is not None:
|
|
labels = [lbl for lbl in labels if lbl["type"] == label_type]
|
|
|
|
return {"success": True, "labels": labels, "count": len(labels)}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error listing schematic labels: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_move_schematic_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Move a schematic component to a new position, dragging connected wires."""
|
|
logger.info("Moving schematic component")
|
|
try:
|
|
from commands.wire_dragger import WireDragger
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
reference = params.get("reference")
|
|
position = params.get("position", {})
|
|
new_x = position.get("x")
|
|
new_y = position.get("y")
|
|
preserve_wires = params.get("preserveWires", True)
|
|
|
|
if not schematic_path or not reference:
|
|
return {
|
|
"success": False,
|
|
"message": "schematicPath and reference are required",
|
|
}
|
|
if new_x is None or new_y is None:
|
|
return {
|
|
"success": False,
|
|
"message": "position with x and y is required",
|
|
}
|
|
|
|
with open(schematic_path, "r", encoding="utf-8") as f:
|
|
sch_data = sexpdata.loads(f.read())
|
|
|
|
# Find symbol and record old position
|
|
found = WireDragger.find_symbol(sch_data, reference)
|
|
if found is None:
|
|
return {"success": False, "message": f"Component {reference} not found"}
|
|
_, old_x, old_y = found[0], found[1], found[2]
|
|
old_position = {"x": old_x, "y": old_y}
|
|
|
|
drag_summary = {}
|
|
if preserve_wires:
|
|
# Compute pin world positions before and after the move
|
|
pin_positions = WireDragger.compute_pin_positions(
|
|
sch_data, reference, float(new_x), float(new_y)
|
|
)
|
|
# Build old→new coordinate map (deduplicate coincident pins)
|
|
old_to_new = {}
|
|
for _pin, (old_xy, new_xy) in pin_positions.items():
|
|
if old_xy in old_to_new:
|
|
logger.warning(
|
|
f"move_schematic_component: pin {_pin!r} of {reference!r} "
|
|
f"shares old position {old_xy} with another pin; "
|
|
f"keeping first entry, skipping duplicate"
|
|
)
|
|
continue
|
|
old_to_new[old_xy] = new_xy
|
|
|
|
drag_summary = WireDragger.drag_wires(sch_data, old_to_new)
|
|
|
|
# Synthesize wires for touching-pin connections after dragging,
|
|
# so drag_wires doesn't accidentally move and collapse the new wire.
|
|
wires_synthesized = WireDragger.synthesize_touching_pin_wires(
|
|
sch_data, reference, pin_positions
|
|
)
|
|
drag_summary["wires_synthesized"] = wires_synthesized
|
|
|
|
# Update symbol position
|
|
WireDragger.update_symbol_position(sch_data, reference, float(new_x), float(new_y))
|
|
|
|
WireManager.sync_junctions(sch_data)
|
|
|
|
with open(schematic_path, "w", encoding="utf-8") as f:
|
|
f.write(sexpdata.dumps(sch_data))
|
|
|
|
return {
|
|
"success": True,
|
|
"oldPosition": old_position,
|
|
"newPosition": {"x": new_x, "y": new_y},
|
|
"wiresMoved": drag_summary.get("endpoints_moved", 0),
|
|
"wiresRemoved": drag_summary.get("wires_removed", 0),
|
|
"wiresSynthesized": drag_summary.get("wires_synthesized", 0),
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error moving schematic component: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_rotate_schematic_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Rotate and/or mirror a schematic component, dragging connected wires."""
|
|
logger.info("Rotating schematic component")
|
|
try:
|
|
import sexpdata as _sexpdata
|
|
from commands.wire_dragger import WireDragger
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
reference = params.get("reference")
|
|
angle = params.get("angle", 0)
|
|
mirror = params.get("mirror") # "x", "y", or None
|
|
|
|
if not schematic_path or not reference:
|
|
return {
|
|
"success": False,
|
|
"message": "schematicPath and reference are required",
|
|
}
|
|
|
|
with open(schematic_path, "r", encoding="utf-8") as f:
|
|
sch_data = _sexpdata.loads(f.read())
|
|
|
|
found = WireDragger.find_symbol(sch_data, reference)
|
|
if found is None:
|
|
return {"success": False, "message": f"Component {reference} not found"}
|
|
|
|
# Determine new mirror state: explicit param overrides; None preserves existing
|
|
_, _, _, _, _, old_mirror_x, old_mirror_y = found
|
|
if mirror is None:
|
|
new_mirror_x = old_mirror_x
|
|
new_mirror_y = old_mirror_y
|
|
effective_mirror = "x" if old_mirror_x else ("y" if old_mirror_y else None)
|
|
else:
|
|
new_mirror_x = mirror == "x"
|
|
new_mirror_y = mirror == "y"
|
|
effective_mirror = mirror
|
|
|
|
# Compute pin world positions before and after the transform
|
|
pin_positions = WireDragger.compute_pin_positions_for_rotation(
|
|
sch_data, reference, float(angle), new_mirror_x, new_mirror_y
|
|
)
|
|
|
|
# Build old→new map (skip pins that don't move)
|
|
old_to_new = {}
|
|
for _pin, (old_xy, new_xy) in pin_positions.items():
|
|
if old_xy == new_xy:
|
|
continue
|
|
if old_xy in old_to_new:
|
|
logger.warning(
|
|
f"rotate: pin {_pin!r} of {reference!r} shares old position "
|
|
f"{old_xy} with another pin; skipping duplicate"
|
|
)
|
|
continue
|
|
old_to_new[old_xy] = new_xy
|
|
|
|
# Drag connected wires to follow pins
|
|
drag_summary = WireDragger.drag_wires(sch_data, old_to_new)
|
|
|
|
# Update the symbol's rotation and mirror token in sexpdata
|
|
WireDragger.update_symbol_rotation_mirror(
|
|
sch_data, reference, float(angle), effective_mirror
|
|
)
|
|
|
|
WireManager.sync_junctions(sch_data)
|
|
|
|
with open(schematic_path, "w", encoding="utf-8") as f:
|
|
f.write(_sexpdata.dumps(sch_data))
|
|
|
|
return {
|
|
"success": True,
|
|
"reference": reference,
|
|
"angle": angle,
|
|
"mirror": effective_mirror,
|
|
"wiresMoved": drag_summary.get("endpoints_moved", 0),
|
|
"wiresRemoved": drag_summary.get("wires_removed", 0),
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error rotating schematic component: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_annotate_schematic(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Annotate unannotated components in schematic (R? -> R1, R2, ...)"""
|
|
logger.info("Annotating schematic")
|
|
try:
|
|
import re
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
# Collect existing references by prefix
|
|
existing_refs = {} # prefix -> set of numbers
|
|
unannotated = [] # (symbol, prefix)
|
|
|
|
for symbol in schematic.symbol:
|
|
if not hasattr(symbol.property, "Reference"):
|
|
continue
|
|
ref = symbol.property.Reference.value
|
|
if ref.startswith("_TEMPLATE"):
|
|
continue
|
|
|
|
# Split reference into prefix and number
|
|
match = re.match(r"^([A-Za-z_]+)(\d+)$", ref)
|
|
if match:
|
|
prefix = match.group(1)
|
|
num = int(match.group(2))
|
|
if prefix not in existing_refs:
|
|
existing_refs[prefix] = set()
|
|
existing_refs[prefix].add(num)
|
|
elif ref.endswith("?"):
|
|
prefix = ref[:-1]
|
|
unannotated.append((symbol, prefix))
|
|
|
|
if not unannotated:
|
|
return {
|
|
"success": True,
|
|
"annotated": [],
|
|
"message": "All components already annotated",
|
|
}
|
|
|
|
annotated = []
|
|
for symbol, prefix in unannotated:
|
|
if prefix not in existing_refs:
|
|
existing_refs[prefix] = set()
|
|
|
|
# Find next available number
|
|
next_num = 1
|
|
while next_num in existing_refs[prefix]:
|
|
next_num += 1
|
|
|
|
old_ref = symbol.property.Reference.value
|
|
new_ref = f"{prefix}{next_num}"
|
|
symbol.setAllReferences(new_ref)
|
|
existing_refs[prefix].add(next_num)
|
|
|
|
uuid_val = str(symbol.uuid.value) if hasattr(symbol, "uuid") else ""
|
|
annotated.append(
|
|
{
|
|
"uuid": uuid_val,
|
|
"oldReference": old_ref,
|
|
"newReference": new_ref,
|
|
}
|
|
)
|
|
|
|
SchematicManager.save_schematic(schematic, schematic_path)
|
|
return {"success": True, "annotated": annotated}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error annotating schematic: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_delete_schematic_wire(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Delete a wire from the schematic matching start/end points"""
|
|
logger.info("Deleting schematic wire")
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
start = params.get("start", {})
|
|
end = params.get("end", {})
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
from pathlib import Path
|
|
|
|
from commands.wire_manager import WireManager
|
|
|
|
start_point = [start.get("x", 0), start.get("y", 0)]
|
|
end_point = [end.get("x", 0), end.get("y", 0)]
|
|
|
|
deleted = WireManager.delete_wire(Path(schematic_path), start_point, end_point)
|
|
if deleted:
|
|
return {"success": True}
|
|
else:
|
|
return {"success": False, "message": "No matching wire found"}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error deleting schematic wire: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_delete_schematic_net_label(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Delete a net label from the schematic"""
|
|
logger.info("Deleting schematic net label")
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
net_name = params.get("netName")
|
|
position = params.get("position")
|
|
|
|
if not schematic_path or not net_name:
|
|
return {
|
|
"success": False,
|
|
"message": "schematicPath and netName are required",
|
|
}
|
|
|
|
from pathlib import Path
|
|
|
|
from commands.wire_manager import WireManager
|
|
|
|
pos_list = None
|
|
if position:
|
|
pos_list = [position.get("x", 0), position.get("y", 0)]
|
|
|
|
deleted = WireManager.delete_label(Path(schematic_path), net_name, pos_list)
|
|
if deleted:
|
|
return {"success": True}
|
|
else:
|
|
return {"success": False, "message": f"Label '{net_name}' not found"}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error deleting schematic net label: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_move_schematic_net_label(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Move a net label to a new position in the schematic."""
|
|
logger.info("Moving schematic net label")
|
|
try:
|
|
import sexpdata as _sexpdata
|
|
from sexpdata import Symbol
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
net_name = params.get("netName")
|
|
new_position = params.get("newPosition", {})
|
|
new_x = new_position.get("x")
|
|
new_y = new_position.get("y")
|
|
current_position = params.get("currentPosition")
|
|
label_type = params.get("labelType")
|
|
|
|
if not schematic_path or not net_name:
|
|
return {"success": False, "message": "schematicPath and netName are required"}
|
|
if new_x is None or new_y is None:
|
|
return {"success": False, "message": "newPosition with x and y is required"}
|
|
|
|
_valid_types = {"label", "global_label", "hierarchical_label"}
|
|
if label_type is not None and label_type not in _valid_types:
|
|
return {
|
|
"success": False,
|
|
"message": f"labelType must be one of: {', '.join(sorted(_valid_types))}",
|
|
}
|
|
|
|
_SYM_AT = Symbol("at")
|
|
target_syms = (
|
|
{Symbol(label_type)}
|
|
if label_type is not None
|
|
else {Symbol(t) for t in _valid_types}
|
|
)
|
|
|
|
TOLERANCE = 0.5
|
|
|
|
with open(schematic_path, "r", encoding="utf-8") as f:
|
|
sch_data = _sexpdata.loads(f.read())
|
|
|
|
for item in sch_data:
|
|
if not (isinstance(item, list) and len(item) >= 2 and item[0] in target_syms):
|
|
continue
|
|
if item[1] != net_name:
|
|
continue
|
|
|
|
at_idx = next(
|
|
(
|
|
j
|
|
for j, p in enumerate(item)
|
|
if isinstance(p, list) and len(p) >= 3 and p[0] == _SYM_AT
|
|
),
|
|
None,
|
|
)
|
|
if at_idx is None:
|
|
continue
|
|
|
|
at_entry = item[at_idx]
|
|
old_x, old_y = float(at_entry[1]), float(at_entry[2])
|
|
|
|
if current_position is not None:
|
|
cx = current_position.get("x", 0)
|
|
cy = current_position.get("y", 0)
|
|
if not (abs(old_x - cx) < TOLERANCE and abs(old_y - cy) < TOLERANCE):
|
|
continue
|
|
|
|
rotation = at_entry[3] if len(at_entry) > 3 else 0
|
|
item[at_idx] = [_SYM_AT, float(new_x), float(new_y), rotation]
|
|
|
|
with open(schematic_path, "w", encoding="utf-8") as f:
|
|
f.write(_sexpdata.dumps(sch_data))
|
|
|
|
return {
|
|
"success": True,
|
|
"oldPosition": {"x": old_x, "y": old_y},
|
|
"newPosition": {"x": float(new_x), "y": float(new_y)},
|
|
}
|
|
|
|
return {"success": False, "message": f"Label '{net_name}' not found"}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error moving schematic net label: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_export_schematic_svg(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Export schematic to SVG using kicad-cli"""
|
|
logger.info("Exporting schematic SVG")
|
|
import glob
|
|
import shutil
|
|
import subprocess
|
|
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
output_path = params.get("outputPath")
|
|
|
|
if not schematic_path or not output_path:
|
|
return {
|
|
"success": False,
|
|
"message": "schematicPath and outputPath are required",
|
|
}
|
|
|
|
if not os.path.exists(schematic_path):
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
# kicad-cli's --output flag for SVG export expects a directory, not a file path.
|
|
# The output file is auto-named based on the schematic name.
|
|
output_dir = os.path.dirname(output_path)
|
|
if not output_dir:
|
|
output_dir = "."
|
|
|
|
os.makedirs(output_dir, exist_ok=True)
|
|
|
|
cmd = [
|
|
"kicad-cli",
|
|
"sch",
|
|
"export",
|
|
"svg",
|
|
schematic_path,
|
|
"-o",
|
|
output_dir,
|
|
]
|
|
|
|
if params.get("blackAndWhite"):
|
|
cmd.append("--black-and-white")
|
|
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
|
|
|
if result.returncode != 0:
|
|
return {
|
|
"success": False,
|
|
"message": f"kicad-cli failed: {result.stderr}",
|
|
}
|
|
|
|
# kicad-cli names the file after the schematic, so find the generated SVG
|
|
svg_files = glob.glob(os.path.join(output_dir, "*.svg"))
|
|
if not svg_files:
|
|
return {
|
|
"success": False,
|
|
"message": "No SVG file produced by kicad-cli",
|
|
}
|
|
|
|
generated_svg = svg_files[0]
|
|
|
|
# Move/rename to the user-specified output path if it differs
|
|
if os.path.abspath(generated_svg) != os.path.abspath(output_path):
|
|
shutil.move(generated_svg, output_path)
|
|
|
|
return {"success": True, "file": {"path": output_path}}
|
|
|
|
except FileNotFoundError:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
except Exception as e:
|
|
logger.error(f"Error exporting schematic SVG: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_get_net_connections(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Get all connections for a named net"""
|
|
logger.info("Getting net connections")
|
|
try:
|
|
from commands.wire_connectivity import get_connections_for_net
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
net_name = params.get("netName")
|
|
|
|
if not all([schematic_path, net_name]):
|
|
return {"success": False, "message": "Missing required parameters"}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
connections = get_connections_for_net(schematic, schematic_path, net_name)
|
|
return {"success": True, "connections": connections}
|
|
except Exception as e:
|
|
logger.error(f"Error getting net connections: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_get_wire_connections(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Find net name and all component pins reachable from a point or component pin."""
|
|
logger.info("Getting wire connections")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.pin_locator import PinLocator
|
|
from commands.wire_connectivity import get_wire_connections
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "Missing required parameter: schematicPath"}
|
|
|
|
reference = params.get("reference")
|
|
pin = params.get("pin")
|
|
x = params.get("x")
|
|
y = params.get("y")
|
|
|
|
has_ref_pin = reference is not None and pin is not None
|
|
has_coords = x is not None and y is not None
|
|
|
|
if has_ref_pin and has_coords:
|
|
return {
|
|
"success": False,
|
|
"message": "Supply either {reference, pin} or {x, y}, not both",
|
|
}
|
|
|
|
if not has_ref_pin and not has_coords:
|
|
if reference is not None or pin is not None:
|
|
return {
|
|
"success": False,
|
|
"message": "Both reference and pin are required together",
|
|
}
|
|
return {
|
|
"success": False,
|
|
"message": "Must supply either {reference, pin} or {x, y}",
|
|
}
|
|
|
|
if has_ref_pin:
|
|
location = PinLocator().get_pin_location(Path(schematic_path), reference, str(pin))
|
|
if location is None:
|
|
return {
|
|
"success": False,
|
|
"message": f"Pin {pin} not found on {reference}",
|
|
}
|
|
x, y = location[0], location[1]
|
|
else:
|
|
try:
|
|
x, y = float(x), float(y)
|
|
except (TypeError, ValueError):
|
|
return {"success": False, "message": "Parameters x and y must be numeric"}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
if not hasattr(schematic, "wire"):
|
|
return {"success": False, "message": "Schematic has no wires"}
|
|
|
|
result = get_wire_connections(schematic, schematic_path, x, y)
|
|
if result is None:
|
|
return {
|
|
"success": False,
|
|
"message": f"No wire found at ({x},{y}) — point may not be connected",
|
|
}
|
|
|
|
return {"success": True, **result}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error getting wire connections: {str(e)}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_get_net_at_point(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Return the net name at a given (x, y) coordinate, or null if none found."""
|
|
logger.info("Getting net at point")
|
|
try:
|
|
from commands.wire_connectivity import get_net_at_point
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "Missing required parameter: schematicPath"}
|
|
|
|
x = params.get("x")
|
|
y = params.get("y")
|
|
if x is None or y is None:
|
|
return {"success": False, "message": "Missing required parameters: x and y"}
|
|
|
|
try:
|
|
x, y = float(x), float(y)
|
|
except (TypeError, ValueError):
|
|
return {"success": False, "message": "Parameters x and y must be numeric"}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
result = get_net_at_point(schematic, schematic_path, x, y)
|
|
return {"success": True, **result}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error getting net at point: {str(e)}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_list_schematic_texts(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List all free-form text annotations (SCH_TEXT) in a schematic."""
|
|
logger.info("Listing schematic text annotations")
|
|
try:
|
|
from commands.wire_manager import WireManager
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
sch_file = Path(schematic_path)
|
|
if not sch_file.exists():
|
|
return {"success": False, "message": f"Schematic not found: {schematic_path}"}
|
|
|
|
texts = WireManager.list_texts(sch_file)
|
|
if texts is None:
|
|
return {"success": False, "message": "Failed to parse schematic"}
|
|
|
|
# Optional text filter
|
|
filter_text = params.get("text")
|
|
if filter_text is not None:
|
|
texts = [t for t in texts if filter_text.lower() in t["text"].lower()]
|
|
|
|
return {"success": True, "texts": texts, "count": len(texts)}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error listing schematic texts: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_add_schematic_text(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a free-form text annotation (SCH_TEXT) to a schematic."""
|
|
logger.info("Adding text annotation to schematic")
|
|
try:
|
|
from commands.wire_manager import WireManager
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
text = params.get("text")
|
|
position = params.get("position")
|
|
angle = params.get("angle", 0)
|
|
font_size = params.get("fontSize", 1.27)
|
|
bold = params.get("bold", False)
|
|
italic = params.get("italic", False)
|
|
justify = params.get("justify", "left")
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
if not text:
|
|
return {"success": False, "message": "text is required"}
|
|
if not position or len(position) != 2:
|
|
return {"success": False, "message": "position [x, y] is required"}
|
|
if justify not in ("left", "center", "right"):
|
|
return {"success": False, "message": "justify must be left, center, or right"}
|
|
if font_size <= 0:
|
|
return {"success": False, "message": "fontSize must be positive"}
|
|
|
|
sch_file = Path(schematic_path)
|
|
if not sch_file.exists():
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
success = WireManager.add_text(
|
|
sch_file,
|
|
text,
|
|
position,
|
|
angle=angle,
|
|
font_size=font_size,
|
|
bold=bold,
|
|
italic=italic,
|
|
justify=justify,
|
|
)
|
|
|
|
if success:
|
|
return {
|
|
"success": True,
|
|
"message": f"Added text '{text}' at ({position[0]}, {position[1]})",
|
|
"position": {"x": position[0], "y": position[1]},
|
|
"angle": angle,
|
|
}
|
|
return {"success": False, "message": "Failed to add text annotation"}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error adding schematic text: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_add_schematic_hierarchical_label(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a hierarchical label to a sub-sheet schematic."""
|
|
logger.info("Adding hierarchical label to schematic")
|
|
try:
|
|
from commands.wire_manager import WireManager
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
text = params.get("text")
|
|
position = params.get("position")
|
|
shape = params.get("shape", "bidirectional")
|
|
orientation = params.get("orientation", 0)
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
if not text:
|
|
return {"success": False, "message": "text is required"}
|
|
if not position or len(position) != 2:
|
|
return {"success": False, "message": "position [x, y] is required"}
|
|
if shape not in ("input", "output", "bidirectional"):
|
|
return {
|
|
"success": False,
|
|
"message": "shape must be input, output, or bidirectional",
|
|
}
|
|
|
|
sch_file = Path(schematic_path)
|
|
if not sch_file.exists():
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
success = WireManager.add_hierarchical_label(
|
|
sch_file, text, position, shape=shape, orientation=orientation
|
|
)
|
|
|
|
if success:
|
|
return {
|
|
"success": True,
|
|
"message": (
|
|
f"Added hierarchical_label '{text}' " f"at {position} shape={shape}"
|
|
),
|
|
}
|
|
return {"success": False, "message": "Failed to add hierarchical label"}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error adding hierarchical label: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_add_sheet_pin(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a sheet pin to a sheet block on the parent schematic."""
|
|
logger.info("Adding sheet pin to schematic")
|
|
try:
|
|
from commands.wire_manager import WireManager
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
sheet_name = params.get("sheetName")
|
|
pin_name = params.get("pinName")
|
|
pin_type = params.get("pinType", "bidirectional")
|
|
position = params.get("position")
|
|
orientation = params.get("orientation", 0)
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
if not sheet_name:
|
|
return {"success": False, "message": "sheetName is required"}
|
|
if not pin_name:
|
|
return {"success": False, "message": "pinName is required"}
|
|
if not position or len(position) != 2:
|
|
return {"success": False, "message": "position [x, y] is required"}
|
|
if pin_type not in ("input", "output", "bidirectional"):
|
|
return {
|
|
"success": False,
|
|
"message": "pinType must be input, output, or bidirectional",
|
|
}
|
|
|
|
sch_file = Path(schematic_path)
|
|
if not sch_file.exists():
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
with open(sch_file, "r", encoding="utf-8") as f:
|
|
content = f.read()
|
|
|
|
modified, success = WireManager.add_sheet_pin(
|
|
content,
|
|
sheet_name,
|
|
pin_name,
|
|
pin_type,
|
|
position,
|
|
orientation=orientation,
|
|
)
|
|
|
|
if not success:
|
|
return {
|
|
"success": False,
|
|
"message": f"Sheet '{sheet_name}' not found in {schematic_path}",
|
|
}
|
|
|
|
with open(sch_file, "w", encoding="utf-8") as f:
|
|
f.write(modified)
|
|
|
|
return {
|
|
"success": True,
|
|
"message": (
|
|
f"Added sheet pin '{pin_name}' ({pin_type}) " f"to sheet '{sheet_name}'"
|
|
),
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error adding sheet pin: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_run_erc(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Run Electrical Rules Check on a schematic via kicad-cli"""
|
|
logger.info("Running ERC on schematic")
|
|
import os
|
|
import subprocess
|
|
import tempfile
|
|
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path or not os.path.exists(schematic_path):
|
|
return {
|
|
"success": False,
|
|
"message": "Schematic file not found",
|
|
"errorDetails": f"Path does not exist: {schematic_path}",
|
|
}
|
|
|
|
kicad_cli = self.design_rule_commands._find_kicad_cli()
|
|
if not kicad_cli:
|
|
return {
|
|
"success": False,
|
|
"message": "kicad-cli not found",
|
|
"errorDetails": "Install KiCAD 8.0+ or add kicad-cli to PATH.",
|
|
}
|
|
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as tmp:
|
|
json_output = tmp.name
|
|
|
|
try:
|
|
cmd = [
|
|
kicad_cli,
|
|
"sch",
|
|
"erc",
|
|
"--format",
|
|
"json",
|
|
"--output",
|
|
json_output,
|
|
schematic_path,
|
|
]
|
|
logger.info(f"Running ERC command: {' '.join(cmd)}")
|
|
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
|
|
|
|
# kicad-cli returns non-zero when ERC violations are found —
|
|
# this is normal, not an error. Only fail when no JSON was
|
|
# produced (genuine CLI failure).
|
|
if not os.path.exists(json_output) or os.path.getsize(json_output) == 0:
|
|
logger.error(f"ERC command produced no output: {result.stderr}")
|
|
return {
|
|
"success": False,
|
|
"message": "ERC command failed - no output produced",
|
|
"errorDetails": result.stderr,
|
|
}
|
|
|
|
with open(json_output, "r", encoding="utf-8") as f:
|
|
erc_data = json.load(f)
|
|
|
|
violations = []
|
|
severity_counts = {"error": 0, "warning": 0, "info": 0}
|
|
|
|
# KiCad 9 nests violations under sheets[].violations
|
|
# instead of (or in addition to) the top-level violations
|
|
# array used by KiCad 8.
|
|
all_violations = erc_data.get("violations", [])
|
|
for sheet in erc_data.get("sheets", []):
|
|
all_violations.extend(sheet.get("violations", []))
|
|
|
|
for v in all_violations:
|
|
vseverity = v.get("severity", "error")
|
|
items = v.get("items", [])
|
|
loc = {}
|
|
if items and "pos" in items[0]:
|
|
loc = {
|
|
"x": items[0]["pos"].get("x", 0),
|
|
"y": items[0]["pos"].get("y", 0),
|
|
}
|
|
violations.append(
|
|
{
|
|
"type": v.get("type", "unknown"),
|
|
"severity": vseverity,
|
|
"message": v.get("description", ""),
|
|
"location": loc,
|
|
}
|
|
)
|
|
if vseverity in severity_counts:
|
|
severity_counts[vseverity] += 1
|
|
|
|
return {
|
|
"success": True,
|
|
"message": f"ERC complete: {len(violations)} violation(s)",
|
|
"summary": {
|
|
"total": len(violations),
|
|
"by_severity": severity_counts,
|
|
},
|
|
"violations": violations,
|
|
}
|
|
|
|
finally:
|
|
if os.path.exists(json_output):
|
|
os.unlink(json_output)
|
|
|
|
except subprocess.TimeoutExpired:
|
|
return {"success": False, "message": "ERC timed out after 120 seconds"}
|
|
except Exception as e:
|
|
logger.error(f"Error running ERC: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
# ------------------------------------------------------------------
|
|
# kicad-cli helper shared by netlist handlers
|
|
# ------------------------------------------------------------------
|
|
|
|
@staticmethod
|
|
def _find_kicad_cli_static() -> Optional[str]:
|
|
"""Return path to kicad-cli executable, or None."""
|
|
import platform
|
|
import shutil
|
|
|
|
cli = shutil.which("kicad-cli")
|
|
if cli:
|
|
return cli
|
|
|
|
system = platform.system()
|
|
if system == "Windows":
|
|
candidates = [
|
|
r"C:\Program Files\KiCad\9.0\bin\kicad-cli.exe",
|
|
r"C:\Program Files\KiCad\8.0\bin\kicad-cli.exe",
|
|
r"C:\Program Files (x86)\KiCad\9.0\bin\kicad-cli.exe",
|
|
r"C:\Program Files (x86)\KiCad\8.0\bin\kicad-cli.exe",
|
|
]
|
|
elif system == "Darwin":
|
|
candidates = [
|
|
"/Applications/KiCad/KiCad.app/Contents/MacOS/kicad-cli",
|
|
"/usr/local/bin/kicad-cli",
|
|
]
|
|
else:
|
|
candidates = [
|
|
"/usr/bin/kicad-cli",
|
|
"/usr/local/bin/kicad-cli",
|
|
]
|
|
for path in candidates:
|
|
if os.path.exists(path):
|
|
return path
|
|
return None
|
|
|
|
# ------------------------------------------------------------------
|
|
|
|
def _handle_export_netlist(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Export netlist to a file using kicad-cli."""
|
|
import subprocess
|
|
|
|
logger.info("Exporting netlist via kicad-cli")
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
output_path = params.get("outputPath")
|
|
fmt = params.get("format", "KiCad")
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
if not output_path:
|
|
return {"success": False, "message": "outputPath is required"}
|
|
if not os.path.exists(schematic_path):
|
|
return {"success": False, "message": f"Schematic not found: {schematic_path}"}
|
|
|
|
kicad_cli = self._find_kicad_cli_static()
|
|
if not kicad_cli:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
|
|
fmt_map = {
|
|
"KiCad": "kicadxml",
|
|
"Spice": "spice",
|
|
"Cadstar": "cadstar",
|
|
"OrcadPCB2": "orcadpcb2",
|
|
}
|
|
cli_format = fmt_map.get(fmt, "kicadxml")
|
|
|
|
os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)
|
|
|
|
cmd = [
|
|
kicad_cli,
|
|
"sch",
|
|
"export",
|
|
"netlist",
|
|
"--format",
|
|
cli_format,
|
|
"--output",
|
|
output_path,
|
|
schematic_path,
|
|
]
|
|
logger.info(f"Running: {' '.join(cmd)}")
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
|
|
|
if result.returncode == 0:
|
|
return {"success": True, "outputPath": output_path, "format": fmt}
|
|
else:
|
|
return {
|
|
"success": False,
|
|
"message": f"kicad-cli failed (exit {result.returncode}): {result.stderr.strip()}",
|
|
}
|
|
|
|
except FileNotFoundError:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
except subprocess.TimeoutExpired:
|
|
return {"success": False, "message": "kicad-cli timed out after 60 seconds"}
|
|
except Exception as e:
|
|
logger.error(f"Error exporting netlist: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_export_gerbers(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Plot multiple Gerbers for a PCB via kicad-cli (`pcb export gerbers`).
|
|
|
|
Exposes the full Plot-dialog option set. Reads the board from disk, so it
|
|
reflects the last *saved* state of the .kicad_pcb. Pass ``boardPath`` to
|
|
target a specific file; otherwise the current board path is used.
|
|
"""
|
|
import subprocess
|
|
|
|
logger.info("Exporting Gerbers via kicad-cli")
|
|
try:
|
|
board_path = params.get("boardPath") or self._current_board_path()
|
|
output_dir = params.get("outputDir")
|
|
|
|
if not board_path:
|
|
return {
|
|
"success": False,
|
|
"message": "boardPath is required (no current board could be resolved)",
|
|
}
|
|
if not os.path.exists(board_path):
|
|
return {"success": False, "message": f"Board not found: {board_path}"}
|
|
if not output_dir:
|
|
return {"success": False, "message": "outputDir is required"}
|
|
|
|
kicad_cli = self._find_kicad_cli_static()
|
|
if not kicad_cli:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
|
|
output_dir = os.path.abspath(os.path.expanduser(output_dir))
|
|
os.makedirs(output_dir, exist_ok=True)
|
|
|
|
cmd = [kicad_cli, "pcb", "export", "gerbers", "--output", output_dir]
|
|
|
|
# Layer selection (accept list or comma string)
|
|
layers = params.get("layers")
|
|
if layers:
|
|
cmd += ["--layers", ",".join(layers) if isinstance(layers, list) else str(layers)]
|
|
common_layers = params.get("commonLayers")
|
|
if common_layers:
|
|
cmd += [
|
|
"--common-layers",
|
|
(
|
|
",".join(common_layers)
|
|
if isinstance(common_layers, list)
|
|
else str(common_layers)
|
|
),
|
|
]
|
|
|
|
if params.get("drawingSheet"):
|
|
cmd += ["--drawing-sheet", params["drawingSheet"]]
|
|
for kv in params.get("defineVar", []) or []:
|
|
cmd += ["--define-var", kv]
|
|
|
|
# Boolean flags (omit to leave at kicad-cli default)
|
|
flag_map = {
|
|
"excludeRefdes": "--exclude-refdes",
|
|
"excludeValue": "--exclude-value",
|
|
"includeBorderTitle": "--include-border-title",
|
|
"sketchPadsOnFabLayers": "--sketch-pads-on-fab-layers",
|
|
"hideDnpFootprintsOnFabLayers": "--hide-DNP-footprints-on-fab-layers",
|
|
"sketchDnpFootprintsOnFabLayers": "--sketch-DNP-footprints-on-fab-layers",
|
|
"crossoutDnpFootprintsOnFabLayers": "--crossout-DNP-footprints-on-fab-layers",
|
|
"noX2": "--no-x2",
|
|
"noNetlist": "--no-netlist",
|
|
"subtractSoldermask": "--subtract-soldermask",
|
|
"disableApertureMacros": "--disable-aperture-macros",
|
|
"useDrillFileOrigin": "--use-drill-file-origin",
|
|
"noProtelExt": "--no-protel-ext",
|
|
"boardPlotParams": "--board-plot-params",
|
|
}
|
|
for key, flag in flag_map.items():
|
|
if params.get(key):
|
|
cmd.append(flag)
|
|
|
|
precision = params.get("precision")
|
|
if precision is not None:
|
|
cmd += ["--precision", str(precision)]
|
|
|
|
cmd.append(board_path)
|
|
|
|
logger.info(f"Running: {' '.join(cmd)}")
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=180)
|
|
|
|
if result.returncode != 0:
|
|
return {
|
|
"success": False,
|
|
"message": f"kicad-cli failed (exit {result.returncode}): "
|
|
f"{result.stderr.strip()}",
|
|
}
|
|
|
|
files = sorted(
|
|
f for f in os.listdir(output_dir) if os.path.isfile(os.path.join(output_dir, f))
|
|
)
|
|
return {"success": True, "outputDir": output_dir, "files": files}
|
|
|
|
except FileNotFoundError:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
except subprocess.TimeoutExpired:
|
|
return {"success": False, "message": "kicad-cli timed out after 180 seconds"}
|
|
except Exception as e:
|
|
logger.error(f"Error exporting Gerbers: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_export_drill(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Generate drill files via kicad-cli (`pcb export drill`).
|
|
|
|
Exposes the full Excellon/Gerber drill option set. Reads the saved
|
|
.kicad_pcb on disk.
|
|
"""
|
|
import subprocess
|
|
|
|
logger.info("Exporting drill files via kicad-cli")
|
|
try:
|
|
board_path = params.get("boardPath") or self._current_board_path()
|
|
output_dir = params.get("outputDir")
|
|
|
|
if not board_path:
|
|
return {
|
|
"success": False,
|
|
"message": "boardPath is required (no current board could be resolved)",
|
|
}
|
|
if not os.path.exists(board_path):
|
|
return {"success": False, "message": f"Board not found: {board_path}"}
|
|
if not output_dir:
|
|
return {"success": False, "message": "outputDir is required"}
|
|
|
|
kicad_cli = self._find_kicad_cli_static()
|
|
if not kicad_cli:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
|
|
output_dir = os.path.abspath(os.path.expanduser(output_dir))
|
|
# kicad-cli drill requires the output dir path to end with a separator
|
|
os.makedirs(output_dir, exist_ok=True)
|
|
|
|
cmd = [kicad_cli, "pcb", "export", "drill", "--output", output_dir + os.sep]
|
|
|
|
# Valued options (omit to use kicad-cli defaults)
|
|
value_map = {
|
|
"format": "--format",
|
|
"drillOrigin": "--drill-origin",
|
|
"excellonZerosFormat": "--excellon-zeros-format",
|
|
"excellonOvalFormat": "--excellon-oval-format",
|
|
"excellonUnits": "--excellon-units",
|
|
"mapFormat": "--map-format",
|
|
"gerberPrecision": "--gerber-precision",
|
|
}
|
|
for key, flag in value_map.items():
|
|
val = params.get(key)
|
|
if val is not None:
|
|
cmd += [flag, str(val)]
|
|
|
|
# Boolean flags
|
|
flag_map = {
|
|
"excellonMirrorY": "--excellon-mirror-y",
|
|
"excellonMinHeader": "--excellon-min-header",
|
|
"excellonSeparateTh": "--excellon-separate-th",
|
|
"generateMap": "--generate-map",
|
|
}
|
|
for key, flag in flag_map.items():
|
|
if params.get(key):
|
|
cmd.append(flag)
|
|
|
|
cmd.append(board_path)
|
|
|
|
logger.info(f"Running: {' '.join(cmd)}")
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
|
|
|
|
if result.returncode != 0:
|
|
return {
|
|
"success": False,
|
|
"message": f"kicad-cli failed (exit {result.returncode}): "
|
|
f"{result.stderr.strip()}",
|
|
}
|
|
|
|
files = sorted(
|
|
f for f in os.listdir(output_dir) if os.path.isfile(os.path.join(output_dir, f))
|
|
)
|
|
return {"success": True, "outputDir": output_dir, "files": files}
|
|
|
|
except FileNotFoundError:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
except subprocess.TimeoutExpired:
|
|
return {"success": False, "message": "kicad-cli timed out after 120 seconds"}
|
|
except Exception as e:
|
|
logger.error(f"Error exporting drill files: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_export_ipc2581(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Export the PCB in IPC-2581 format via kicad-cli (`pcb export ipc2581`).
|
|
|
|
IPC-2581 is a single-file MES/CAD interchange format carrying placement,
|
|
nets, and BOM part data inline. The bom-col-* params map schematic fields
|
|
to the BOM columns embedded in the file. Reads the saved .kicad_pcb.
|
|
"""
|
|
import subprocess
|
|
|
|
logger.info("Exporting IPC-2581 via kicad-cli")
|
|
try:
|
|
board_path = params.get("boardPath") or self._current_board_path()
|
|
output_path = params.get("outputPath")
|
|
|
|
if not board_path:
|
|
return {
|
|
"success": False,
|
|
"message": "boardPath is required (no current board could be resolved)",
|
|
}
|
|
if not os.path.exists(board_path):
|
|
return {"success": False, "message": f"Board not found: {board_path}"}
|
|
if not output_path:
|
|
return {"success": False, "message": "outputPath is required"}
|
|
|
|
kicad_cli = self._find_kicad_cli_static()
|
|
if not kicad_cli:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
|
|
output_path = os.path.abspath(os.path.expanduser(output_path))
|
|
os.makedirs(os.path.dirname(output_path), exist_ok=True)
|
|
|
|
cmd = [kicad_cli, "pcb", "export", "ipc2581", "--output", output_path]
|
|
|
|
if params.get("drawingSheet"):
|
|
cmd += ["--drawing-sheet", params["drawingSheet"]]
|
|
for kv in params.get("defineVar", []) or []:
|
|
cmd += ["--define-var", kv]
|
|
|
|
value_map = {
|
|
"precision": "--precision",
|
|
"version": "--version",
|
|
"units": "--units",
|
|
"bomColIntId": "--bom-col-int-id",
|
|
"bomColMfgPn": "--bom-col-mfg-pn",
|
|
"bomColMfg": "--bom-col-mfg",
|
|
"bomColDistPn": "--bom-col-dist-pn",
|
|
"bomColDist": "--bom-col-dist",
|
|
}
|
|
for key, flag in value_map.items():
|
|
val = params.get(key)
|
|
if val is not None and val != "":
|
|
cmd += [flag, str(val)]
|
|
|
|
if params.get("compress"):
|
|
cmd.append("--compress")
|
|
|
|
cmd.append(board_path)
|
|
|
|
logger.info(f"Running: {' '.join(cmd)}")
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=180)
|
|
|
|
if result.returncode != 0:
|
|
return {
|
|
"success": False,
|
|
"message": f"kicad-cli failed (exit {result.returncode}): "
|
|
f"{result.stderr.strip()}",
|
|
}
|
|
return {"success": True, "outputPath": output_path}
|
|
|
|
except FileNotFoundError:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
except subprocess.TimeoutExpired:
|
|
return {"success": False, "message": "kicad-cli timed out after 180 seconds"}
|
|
except Exception as e:
|
|
logger.error(f"Error exporting IPC-2581: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_generate_netlist(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Generate netlist from schematic and return structured JSON.
|
|
|
|
Uses kicad-cli to export KiCad XML netlist to a temp file, then
|
|
parses it into {components, nets} structure expected by the TS handler.
|
|
"""
|
|
import subprocess
|
|
import tempfile
|
|
import xml.etree.ElementTree as ET
|
|
|
|
logger.info("Generating netlist from schematic via kicad-cli")
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "Schematic path is required"}
|
|
if not os.path.exists(schematic_path):
|
|
return {"success": False, "message": f"Schematic not found: {schematic_path}"}
|
|
|
|
kicad_cli = self._find_kicad_cli_static()
|
|
if not kicad_cli:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
|
|
with tempfile.NamedTemporaryFile(suffix=".xml", delete=False) as tmp:
|
|
tmp_path = tmp.name
|
|
|
|
try:
|
|
cmd = [
|
|
kicad_cli,
|
|
"sch",
|
|
"export",
|
|
"netlist",
|
|
"--format",
|
|
"kicadxml",
|
|
"--output",
|
|
tmp_path,
|
|
schematic_path,
|
|
]
|
|
logger.info(f"Running: {' '.join(cmd)}")
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
|
|
|
if result.returncode != 0:
|
|
return {
|
|
"success": False,
|
|
"message": f"kicad-cli failed (exit {result.returncode}): {result.stderr.strip()}",
|
|
}
|
|
|
|
tree = ET.parse(tmp_path)
|
|
root = tree.getroot()
|
|
|
|
components = []
|
|
for comp in root.findall("./components/comp"):
|
|
ref = comp.get("ref", "")
|
|
value = comp.findtext("value", "")
|
|
footprint = comp.findtext("footprint", "")
|
|
components.append({"reference": ref, "value": value, "footprint": footprint})
|
|
|
|
nets = []
|
|
for net in root.findall("./nets/net"):
|
|
net_name = net.get("name", "")
|
|
connections = []
|
|
for node in net.findall("node"):
|
|
connections.append(
|
|
{
|
|
"component": node.get("ref", ""),
|
|
"pin": node.get("pin", ""),
|
|
}
|
|
)
|
|
nets.append({"name": net_name, "connections": connections})
|
|
|
|
logger.info(f"Generated netlist: {len(components)} components, {len(nets)} nets")
|
|
return {"success": True, "netlist": {"components": components, "nets": nets}}
|
|
|
|
finally:
|
|
try:
|
|
os.unlink(tmp_path)
|
|
except OSError:
|
|
pass
|
|
|
|
except FileNotFoundError:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
except subprocess.TimeoutExpired:
|
|
return {"success": False, "message": "kicad-cli timed out after 60 seconds"}
|
|
except Exception as e:
|
|
logger.error(f"Error generating netlist: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _build_hierarchical_pad_net_map(self, project_sch_path: str):
|
|
"""Walk all .kicad_sch files in the project and build a {(ref, pin_num): net_name} map.
|
|
|
|
Handles hierarchical schematics by scanning every sub-sheet file. Net names
|
|
from global_label / hierarchical_label / local label / power symbols are all
|
|
collected. Wire connectivity is traced via BFS so labels not placed directly
|
|
on a pin endpoint still reach through wire segments.
|
|
|
|
Returns: (pad_net_map, net_names_set)
|
|
"""
|
|
from collections import defaultdict
|
|
from pathlib import Path
|
|
|
|
from commands.pin_locator import PinLocator
|
|
from skip import Schematic
|
|
|
|
TOLERANCE = 0.5 # mm; schematic grid is 1.27 mm so 0.5 is safe
|
|
|
|
def snap(x, y):
|
|
"""Round to 2 dp to use exact dict lookup instead of O(n²) scan."""
|
|
return (round(float(x), 2), round(float(y), 2))
|
|
|
|
def nearby_net(pt, point_net, tol=TOLERANCE):
|
|
"""Return net name for the nearest occupied grid point, or None."""
|
|
x, y = pt
|
|
# Try exact snap first (fast path)
|
|
key = snap(x, y)
|
|
if key in point_net:
|
|
return point_net[key]
|
|
# Slow fallback for off-grid placements
|
|
for (lx, ly), name in point_net.items():
|
|
if abs(x - lx) < tol and abs(y - ly) < tol:
|
|
return name
|
|
return None
|
|
|
|
project_dir = Path(project_sch_path).parent
|
|
pad_net_map: dict = {}
|
|
all_net_names: set = set()
|
|
pin_locator = PinLocator()
|
|
|
|
sch_files = sorted(project_dir.rglob("*.kicad_sch"))
|
|
logger.info(f"_build_hierarchical_pad_net_map: scanning {len(sch_files)} schematic files")
|
|
|
|
for sch_path in sch_files:
|
|
try:
|
|
sch = Schematic(str(sch_path))
|
|
except Exception as e:
|
|
logger.warning(f"Could not load {sch_path}: {e}")
|
|
continue
|
|
|
|
# ── 1. Collect explicit label positions → net name ──────────────
|
|
point_net: dict = {} # snap(x,y) -> net_name
|
|
|
|
for attr in ("label", "global_label", "hierarchical_label"):
|
|
for lbl in getattr(sch, attr, None) or []:
|
|
try:
|
|
pos = lbl.at.value
|
|
name = lbl.value
|
|
if name:
|
|
k = snap(pos[0], pos[1])
|
|
point_net[k] = name
|
|
all_net_names.add(name)
|
|
except Exception:
|
|
pass
|
|
|
|
# Power symbols (#PWR / #FLG): value property IS the net name; use pin 1 pos
|
|
for sym in getattr(sch, "symbol", None) or []:
|
|
try:
|
|
ref = sym.property.Reference.value
|
|
if not (ref.startswith("#PWR") or ref.startswith("#FLG")):
|
|
continue
|
|
net_name = sym.property.Value.value
|
|
if not net_name:
|
|
continue
|
|
all_pins = pin_locator.get_all_symbol_pins(sch_path, ref)
|
|
for _pin_num, (px, py) in all_pins.items():
|
|
k = snap(px, py)
|
|
point_net[k] = net_name
|
|
all_net_names.add(net_name)
|
|
except Exception:
|
|
pass
|
|
|
|
# ── 2. Build wire adjacency and BFS-propagate net names ──────────
|
|
wire_segments = []
|
|
for wire in getattr(sch, "wire", None) or []:
|
|
try:
|
|
pts = []
|
|
for pt in wire.pts.xy:
|
|
pts.append(snap(pt.value[0], pt.value[1]))
|
|
if len(pts) >= 2:
|
|
wire_segments.append(pts)
|
|
except Exception:
|
|
pass
|
|
|
|
# Adjacency: connect endpoints of different segments that share a grid point
|
|
point_adj: dict = defaultdict(set)
|
|
for seg in wire_segments:
|
|
# Connect consecutive points within the segment
|
|
for i in range(len(seg) - 1):
|
|
point_adj[seg[i]].add(seg[i + 1])
|
|
point_adj[seg[i + 1]].add(seg[i])
|
|
|
|
# All unique wire points
|
|
all_wire_pts = set()
|
|
for seg in wire_segments:
|
|
all_wire_pts.update(seg)
|
|
|
|
# BFS: propagate known net names through wire connections
|
|
queue = [pt for pt in all_wire_pts if pt in point_net]
|
|
visited = set(queue)
|
|
while queue:
|
|
pt = queue.pop()
|
|
net = point_net[pt]
|
|
for neighbor in point_adj[pt]:
|
|
if neighbor not in point_net:
|
|
point_net[neighbor] = net
|
|
all_net_names.add(net)
|
|
if neighbor not in visited:
|
|
visited.add(neighbor)
|
|
queue.append(neighbor)
|
|
|
|
# ── 3. Match component pin positions to net names ────────────────
|
|
for sym in getattr(sch, "symbol", None) or []:
|
|
try:
|
|
ref = sym.property.Reference.value
|
|
if ref.startswith("#"):
|
|
continue
|
|
except Exception:
|
|
continue
|
|
|
|
pin_positions = pin_locator.get_all_symbol_pins(sch_path, ref)
|
|
for pin_num, (px, py) in pin_positions.items():
|
|
net = nearby_net((px, py), point_net)
|
|
if net:
|
|
pad_net_map[(ref, pin_num)] = net
|
|
|
|
logger.info(
|
|
f"_build_hierarchical_pad_net_map: {len(pad_net_map)} pin→net assignments, "
|
|
f"{len(all_net_names)} unique nets"
|
|
)
|
|
return pad_net_map, all_net_names
|
|
|
|
def _handle_sync_schematic_to_board(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Sync schematic netlist to PCB board (equivalent to KiCAD F8 'Update PCB from Schematic').
|
|
Reads net connections from the schematic and assigns them to the matching pads in the PCB.
|
|
"""
|
|
logger.info("Syncing schematic to board")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
board_path = params.get("boardPath")
|
|
|
|
# Determine board to work with
|
|
board = None
|
|
if board_path:
|
|
board = self._safe_load_board(board_path)
|
|
if board is None:
|
|
return {
|
|
"success": False,
|
|
"message": f"Could not load board from {board_path}",
|
|
"errorDetails": (
|
|
"pcbnew.LoadBoard failed or returned a dehydrated "
|
|
"SWIG proxy that could not be recovered"
|
|
),
|
|
}
|
|
elif self.board:
|
|
board = self.board
|
|
board_path = board.GetFileName() if not board_path else board_path
|
|
else:
|
|
return {
|
|
"success": False,
|
|
"message": "No board loaded. Use open_project first or provide boardPath.",
|
|
}
|
|
|
|
if not board_path:
|
|
board_path = board.GetFileName()
|
|
|
|
# Determine schematic path if not provided
|
|
if not schematic_path:
|
|
sch = Path(board_path).with_suffix(".kicad_sch")
|
|
if sch.exists():
|
|
schematic_path = str(sch)
|
|
else:
|
|
project_dir = Path(board_path).parent
|
|
sch_files = list(project_dir.glob("*.kicad_sch"))
|
|
if sch_files:
|
|
schematic_path = str(sch_files[0])
|
|
|
|
if not schematic_path or not Path(schematic_path).exists():
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found. Provide schematicPath. Tried: {schematic_path}",
|
|
}
|
|
|
|
# Build hierarchical pad→net map (walks all sub-sheets)
|
|
pad_net_map, net_names = self._build_hierarchical_pad_net_map(schematic_path)
|
|
|
|
# Add missing footprints from the schematic to the board *before*
|
|
# we add nets and assign pads — F8 in KiCad does this implicitly
|
|
# ("Update PCB from Schematic"), but our previous implementation
|
|
# only mutated nets, leaving newly-added schematic symbols with no
|
|
# PCB footprint at all.
|
|
added_footprints, skipped_footprints = self._add_missing_footprints_from_schematic(
|
|
board, schematic_path
|
|
)
|
|
|
|
# Add all nets to board
|
|
netinfo = board.GetNetInfo()
|
|
nets_by_name = netinfo.NetsByName()
|
|
added_nets = []
|
|
for net_name in net_names:
|
|
if not nets_by_name.has_key(net_name):
|
|
net_item = pcbnew.NETINFO_ITEM(board, net_name)
|
|
board.Add(net_item)
|
|
added_nets.append(net_name)
|
|
|
|
# Refresh nets map after additions
|
|
netinfo = board.GetNetInfo()
|
|
nets_by_name = netinfo.NetsByName()
|
|
|
|
# Assign nets to pads (now also covers any footprints we just added)
|
|
assigned_pads = 0
|
|
unmatched = []
|
|
for fp in board.GetFootprints():
|
|
ref = fp.GetReference()
|
|
for pad in fp.Pads():
|
|
pad_num = pad.GetNumber()
|
|
key = (ref, str(pad_num))
|
|
if key in pad_net_map:
|
|
net_name = pad_net_map[key]
|
|
if nets_by_name.has_key(net_name):
|
|
pad.SetNet(nets_by_name[net_name])
|
|
assigned_pads += 1
|
|
else:
|
|
unmatched.append(f"{ref}/{pad_num}")
|
|
|
|
board.Save(board_path)
|
|
|
|
# If board was loaded fresh, update internal reference
|
|
if params.get("boardPath"):
|
|
self.board = board
|
|
self._update_command_handlers()
|
|
|
|
logger.info(
|
|
f"sync_schematic_to_board: {len(added_nets)} nets added, "
|
|
f"{len(added_footprints)} footprints added, {assigned_pads} pads assigned"
|
|
)
|
|
return {
|
|
"success": True,
|
|
"message": (
|
|
f"PCB updated from schematic: {len(added_footprints)} footprints added, "
|
|
f"{len(added_nets)} nets added, {assigned_pads} pads assigned"
|
|
),
|
|
"nets_added": added_nets,
|
|
"nets_total": len(net_names),
|
|
"pads_assigned": assigned_pads,
|
|
"unmatched_pads_sample": unmatched[:10],
|
|
"footprints_added": added_footprints,
|
|
"footprints_skipped": skipped_footprints,
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in sync_schematic_to_board: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _extract_components_from_schematic(self, schematic_path: str) -> List[Dict[str, str]]:
|
|
"""Run kicad-cli netlist export and return the flat list of components.
|
|
|
|
Each entry: {"reference": str, "value": str, "footprint": str}
|
|
Empty list on any failure (kicad-cli missing, parse error, etc.) — the
|
|
caller treats that as "no missing footprints to add".
|
|
"""
|
|
import subprocess
|
|
import tempfile
|
|
import xml.etree.ElementTree as ET
|
|
|
|
kicad_cli = self._find_kicad_cli_static()
|
|
if not kicad_cli:
|
|
logger.warning("kicad-cli not found — sync will not add new footprints")
|
|
return []
|
|
|
|
with tempfile.NamedTemporaryFile(suffix=".xml", delete=False) as tmp:
|
|
tmp_path = tmp.name
|
|
try:
|
|
cmd = [
|
|
kicad_cli,
|
|
"sch",
|
|
"export",
|
|
"netlist",
|
|
"--format",
|
|
"kicadxml",
|
|
"--output",
|
|
tmp_path,
|
|
schematic_path,
|
|
]
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
|
if result.returncode != 0:
|
|
logger.warning(
|
|
f"kicad-cli netlist export failed (exit {result.returncode}): "
|
|
f"{result.stderr.strip()}"
|
|
)
|
|
return []
|
|
|
|
tree = ET.parse(tmp_path)
|
|
root = tree.getroot()
|
|
components = []
|
|
for comp in root.findall("./components/comp"):
|
|
components.append(
|
|
{
|
|
"reference": comp.get("ref", ""),
|
|
"value": comp.findtext("value", ""),
|
|
"footprint": comp.findtext("footprint", ""),
|
|
}
|
|
)
|
|
return components
|
|
except Exception as e:
|
|
logger.warning(f"Failed to extract components from schematic: {e}")
|
|
return []
|
|
finally:
|
|
try:
|
|
os.unlink(tmp_path)
|
|
except OSError:
|
|
pass
|
|
|
|
def _add_missing_footprints_from_schematic(
|
|
self, board: Any, schematic_path: str
|
|
) -> Tuple[List[Dict[str, str]], List[Dict[str, str]]]:
|
|
"""Add footprints to ``board`` for any schematic component not yet present.
|
|
|
|
New footprints are placed at the board origin so the user can move them
|
|
into position. Power/flag references (``#PWR``, ``#FLG``) are skipped —
|
|
they have no PCB representation.
|
|
|
|
Returns ``(added, skipped)``: each entry is
|
|
``{"reference": str, "footprint": str, "reason": str?}``.
|
|
"""
|
|
from pathlib import Path
|
|
|
|
from commands.library import LibraryManager
|
|
|
|
added: List[Dict[str, str]] = []
|
|
skipped: List[Dict[str, str]] = []
|
|
|
|
components = self._extract_components_from_schematic(schematic_path)
|
|
if not components:
|
|
return added, skipped
|
|
|
|
existing_refs = {fp.GetReference() for fp in board.GetFootprints()}
|
|
project_dir = Path(schematic_path).parent
|
|
library_manager = LibraryManager(project_path=project_dir)
|
|
|
|
for comp in components:
|
|
ref = comp["reference"]
|
|
fp_str = comp["footprint"]
|
|
if not ref or ref.startswith("#"):
|
|
# Power flags / global indicators — no PCB footprint expected.
|
|
continue
|
|
if ref in existing_refs:
|
|
continue
|
|
if not fp_str or ":" not in fp_str:
|
|
skipped.append(
|
|
{
|
|
"reference": ref,
|
|
"footprint": fp_str,
|
|
"reason": "no Library:Name footprint set on schematic symbol",
|
|
}
|
|
)
|
|
continue
|
|
|
|
lib_name, fp_name = fp_str.split(":", 1)
|
|
library_path = library_manager.libraries.get(lib_name)
|
|
if not library_path:
|
|
skipped.append(
|
|
{
|
|
"reference": ref,
|
|
"footprint": fp_str,
|
|
"reason": f"library '{lib_name}' not in fp-lib-table",
|
|
}
|
|
)
|
|
continue
|
|
|
|
try:
|
|
module = pcbnew.FootprintLoad(library_path, fp_name)
|
|
except Exception as e:
|
|
skipped.append(
|
|
{"reference": ref, "footprint": fp_str, "reason": f"FootprintLoad failed: {e}"}
|
|
)
|
|
continue
|
|
|
|
if not module:
|
|
skipped.append(
|
|
{
|
|
"reference": ref,
|
|
"footprint": fp_str,
|
|
"reason": f"footprint '{fp_name}' not in '{lib_name}'",
|
|
}
|
|
)
|
|
continue
|
|
|
|
module.SetReference(ref)
|
|
if comp["value"]:
|
|
module.SetValue(comp["value"])
|
|
module.SetFPID(pcbnew.LIB_ID(lib_name, fp_name))
|
|
# Place at board origin; user / autoplacer can position from there.
|
|
module.SetPosition(pcbnew.VECTOR2I(0, 0))
|
|
|
|
board.Add(module)
|
|
existing_refs.add(ref)
|
|
added.append({"reference": ref, "footprint": fp_str})
|
|
|
|
if added:
|
|
logger.info(f"_add_missing_footprints_from_schematic: added {len(added)} footprints")
|
|
return added, skipped
|
|
|
|
# ===================================================================
|
|
# Schematic analysis tools (read-only)
|
|
# ===================================================================
|
|
|
|
def _handle_get_schematic_view_region(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Export a cropped region of the schematic as an image"""
|
|
logger.info("Exporting schematic view region")
|
|
import base64
|
|
import os
|
|
import subprocess
|
|
import tempfile
|
|
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path or not os.path.exists(schematic_path):
|
|
return {"success": False, "message": "Schematic file not found"}
|
|
|
|
x1 = float(params.get("x1", 0))
|
|
y1 = float(params.get("y1", 0))
|
|
x2 = float(params.get("x2", 297))
|
|
y2 = float(params.get("y2", 210))
|
|
x1, x2 = min(x1, x2), max(x1, x2)
|
|
y1, y2 = min(y1, y2), max(y1, y2)
|
|
out_format = params.get("format", "png")
|
|
width = int(params.get("width", 800))
|
|
height = int(params.get("height", 600))
|
|
|
|
kicad_cli = self.design_rule_commands._find_kicad_cli()
|
|
if not kicad_cli:
|
|
return {"success": False, "message": "kicad-cli not found"}
|
|
|
|
tmp_dir = tempfile.mkdtemp()
|
|
svg_output = None
|
|
|
|
try:
|
|
cmd = [
|
|
kicad_cli,
|
|
"sch",
|
|
"export",
|
|
"svg",
|
|
"--output",
|
|
tmp_dir,
|
|
schematic_path,
|
|
]
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
|
|
|
if result.returncode != 0:
|
|
return {
|
|
"success": False,
|
|
"message": f"SVG export failed: {result.stderr}",
|
|
}
|
|
|
|
# kicad-cli names the file after the schematic
|
|
svg_files = [f for f in os.listdir(tmp_dir) if f.endswith(".svg")]
|
|
if not svg_files:
|
|
return {
|
|
"success": False,
|
|
"message": "kicad-cli produced no SVG output",
|
|
}
|
|
svg_output = os.path.join(tmp_dir, svg_files[0])
|
|
|
|
import xml.etree.ElementTree as ET
|
|
|
|
tree = ET.parse(svg_output)
|
|
root = tree.getroot()
|
|
|
|
# KiCad schematic SVGs use mm as viewBox units directly
|
|
vb = root.get("viewBox", "")
|
|
if vb:
|
|
parts = vb.split()
|
|
if len(parts) == 4:
|
|
orig_vb_x = float(parts[0])
|
|
orig_vb_y = float(parts[1])
|
|
|
|
new_x = orig_vb_x + x1
|
|
new_y = orig_vb_y + y1
|
|
new_w = x2 - x1
|
|
new_h = y2 - y1
|
|
|
|
root.set("viewBox", f"{new_x} {new_y} {new_w} {new_h}")
|
|
root.set("width", str(width))
|
|
root.set("height", str(height))
|
|
|
|
# Write modified SVG
|
|
cropped_svg_path = os.path.join(tmp_dir, "cropped.svg")
|
|
tree.write(cropped_svg_path, xml_declaration=True, encoding="utf-8")
|
|
|
|
if out_format == "svg":
|
|
with open(cropped_svg_path, "r", encoding="utf-8") as f:
|
|
svg_data = f.read()
|
|
return {"success": True, "imageData": svg_data, "format": "svg"}
|
|
else:
|
|
png_data = _svg_to_png(cropped_svg_path, width, height)
|
|
if png_data is None:
|
|
return {
|
|
"success": False,
|
|
"message": "No PNG converter available. Install pymupdf, inkscape, or imagemagick.",
|
|
}
|
|
return {
|
|
"success": True,
|
|
"imageData": base64.b64encode(png_data).decode("utf-8"),
|
|
"format": "png",
|
|
}
|
|
finally:
|
|
import shutil
|
|
|
|
shutil.rmtree(tmp_dir, ignore_errors=True)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in get_schematic_view_region: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_find_overlapping_elements(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Detect spatially overlapping symbols, wires, and labels"""
|
|
logger.info("Finding overlapping elements in schematic")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.schematic_analysis import find_overlapping_elements
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
tolerance = float(params.get("tolerance", 0.5))
|
|
result = find_overlapping_elements(Path(schematic_path), tolerance)
|
|
return {
|
|
"success": True,
|
|
**result,
|
|
"message": f"Found {result['totalOverlaps']} overlap(s)",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error finding overlapping elements: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_get_elements_in_region(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List all wires, labels, and symbols within a rectangular region"""
|
|
logger.info("Getting elements in schematic region")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.schematic_analysis import get_elements_in_region
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
x1 = float(params.get("x1", 0))
|
|
y1 = float(params.get("y1", 0))
|
|
x2 = float(params.get("x2", 0))
|
|
y2 = float(params.get("y2", 0))
|
|
|
|
result = get_elements_in_region(Path(schematic_path), x1, y1, x2, y2)
|
|
return {
|
|
"success": True,
|
|
**result,
|
|
"message": f"Found {result['counts']['symbols']} symbols, {result['counts']['wires']} wires, {result['counts']['labels']} labels in region",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error getting elements in region: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_find_wires_crossing_symbols(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Find wires that cross over component symbol bodies"""
|
|
logger.info("Finding wires crossing symbols in schematic")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.schematic_analysis import find_wires_crossing_symbols
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
result = find_wires_crossing_symbols(Path(schematic_path))
|
|
return {
|
|
"success": True,
|
|
"collisions": result,
|
|
"count": len(result),
|
|
"message": f"Found {len(result)} wire(s) crossing symbols",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error checking wire collisions: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_find_orphaned_wires(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Find wire segments with at least one dangling (unconnected) endpoint"""
|
|
logger.info("Finding orphaned wires in schematic")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.schematic_analysis import find_orphaned_wires
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
result = find_orphaned_wires(Path(schematic_path))
|
|
return {
|
|
"success": True,
|
|
**result,
|
|
"message": f"Found {result['count']} orphaned wire(s)",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error finding orphaned wires: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_list_floating_labels(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List net labels that are not connected to any component pin"""
|
|
logger.info("Listing floating net labels in schematic")
|
|
try:
|
|
from commands.wire_connectivity import list_floating_labels
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
labels = list_floating_labels(schematic, schematic_path)
|
|
return {
|
|
"success": True,
|
|
"floating_labels": labels,
|
|
"count": len(labels),
|
|
"message": f"Found {len(labels)} floating label(s)",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error listing floating labels: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_snap_to_grid(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Snap schematic element coordinates to the nearest grid point"""
|
|
logger.info("Snapping schematic elements to grid")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.schematic_snap import snap_to_grid
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
grid_size = float(params.get("gridSize", 1.27))
|
|
elements = params.get("elements") # None → defaults inside snap_to_grid
|
|
|
|
result = snap_to_grid(Path(schematic_path), grid_size=grid_size, elements=elements)
|
|
total = result["snapped"] + result["already_on_grid"]
|
|
return {
|
|
"success": True,
|
|
**result,
|
|
"message": (
|
|
f"Snapped {result['snapped']} element(s) to {grid_size} mm grid "
|
|
f"({result['already_on_grid']} of {total} were already on grid)"
|
|
),
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error snapping to grid: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_import_svg_logo(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Import an SVG file as PCB graphic polygons on the silkscreen"""
|
|
logger.info("Importing SVG logo into PCB")
|
|
try:
|
|
from commands.svg_import import import_svg_to_pcb
|
|
|
|
pcb_path = params.get("pcbPath")
|
|
svg_path = params.get("svgPath")
|
|
x = float(params.get("x", 0))
|
|
y = float(params.get("y", 0))
|
|
width = float(params.get("width", 10))
|
|
layer = params.get("layer", "F.SilkS")
|
|
stroke_width = float(params.get("strokeWidth", 0))
|
|
filled = bool(params.get("filled", True))
|
|
|
|
if not pcb_path or not svg_path:
|
|
return {
|
|
"success": False,
|
|
"message": "Missing required parameters: pcbPath, svgPath",
|
|
}
|
|
|
|
result = import_svg_to_pcb(pcb_path, svg_path, x, y, width, layer, stroke_width, filled)
|
|
|
|
# import_svg_to_pcb writes gr_poly entries directly to the .kicad_pcb file,
|
|
# bypassing the pcbnew in-memory board object. Any subsequent board.Save()
|
|
# call would overwrite the file with the stale in-memory state, erasing the
|
|
# logo. Reload the board from disk so pcbnew's memory matches the file.
|
|
if result.get("success") and self.board:
|
|
reloaded = self._safe_load_board(pcb_path)
|
|
if reloaded is not None:
|
|
self.board = reloaded
|
|
self._update_command_handlers()
|
|
logger.info("Reloaded board into pcbnew after SVG logo import")
|
|
else:
|
|
logger.warning(
|
|
"Board reload after SVG import failed (non-fatal); "
|
|
"next mutation may operate on stale in-memory state"
|
|
)
|
|
|
|
return result
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error importing SVG logo: {str(e)}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_snapshot_project(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Copy the entire project folder to a snapshot directory for checkpoint/resume."""
|
|
import shutil
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
|
|
try:
|
|
step = params.get("step", "")
|
|
label = params.get("label", "")
|
|
prompt_text = params.get("prompt", "")
|
|
# Determine project directory from loaded board or explicit path
|
|
project_dir = None
|
|
if self.board:
|
|
board_file = self.board.GetFileName()
|
|
if board_file:
|
|
project_dir = str(Path(board_file).parent)
|
|
if not project_dir:
|
|
project_dir = params.get("projectPath")
|
|
if not project_dir or not os.path.isdir(project_dir):
|
|
return {
|
|
"success": False,
|
|
"message": "Could not determine project directory for snapshot",
|
|
}
|
|
|
|
ts = datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
|
# Save prompt + log into logs/ subdirectory before snapshotting
|
|
logs_dir = Path(project_dir) / "logs"
|
|
logs_dir.mkdir(exist_ok=True)
|
|
|
|
prompt_file = None
|
|
if prompt_text:
|
|
prompt_filename = f"PROMPT_step{step}_{ts}.md" if step else f"PROMPT_{ts}.md"
|
|
prompt_file = logs_dir / prompt_filename
|
|
prompt_file.write_text(prompt_text, encoding="utf-8")
|
|
logger.info(f"Prompt saved: {prompt_file}")
|
|
|
|
# Copy current MCP session log into logs/ before snapshotting
|
|
import platform
|
|
|
|
system = platform.system()
|
|
if system == "Windows":
|
|
mcp_log_dir = os.path.join(os.environ.get("APPDATA", ""), "Claude", "logs")
|
|
elif system == "Darwin":
|
|
mcp_log_dir = os.path.expanduser("~/Library/Logs/Claude")
|
|
else:
|
|
mcp_log_dir = os.path.expanduser("~/.config/Claude/logs")
|
|
mcp_log_src = os.path.join(mcp_log_dir, "mcp-server-kicad.log")
|
|
mcp_log_dest = None
|
|
if os.path.exists(mcp_log_src):
|
|
with open(mcp_log_src, "r", encoding="utf-8", errors="replace") as f:
|
|
all_lines = f.readlines()
|
|
session_start = 0
|
|
for i, line in enumerate(all_lines):
|
|
if "Initializing server" in line:
|
|
session_start = i
|
|
session_lines = all_lines[session_start:]
|
|
log_filename = f"mcp_log_step{step}_{ts}.txt" if step else f"mcp_log_{ts}.txt"
|
|
mcp_log_dest = logs_dir / log_filename
|
|
with open(mcp_log_dest, "w", encoding="utf-8") as f:
|
|
f.writelines(session_lines)
|
|
logger.info(f"MCP session log saved: {mcp_log_dest} ({len(session_lines)} lines)")
|
|
|
|
base_name = Path(project_dir).name
|
|
suffix_parts = [p for p in [f"step{step}" if step else "", label, ts] if p]
|
|
snapshot_name = base_name + "_snapshot_" + "_".join(suffix_parts)
|
|
snapshots_base = Path(project_dir) / "snapshots"
|
|
snapshots_base.mkdir(exist_ok=True)
|
|
snapshot_dir = str(snapshots_base / snapshot_name)
|
|
|
|
shutil.copytree(project_dir, snapshot_dir, ignore=shutil.ignore_patterns("snapshots"))
|
|
logger.info(f"Project snapshot saved: {snapshot_dir}")
|
|
return {
|
|
"success": True,
|
|
"message": f"Snapshot saved: {snapshot_name}",
|
|
"snapshotPath": snapshot_dir,
|
|
"sourceDir": project_dir,
|
|
"promptSaved": str(prompt_file) if prompt_file else None,
|
|
"mcpLogSaved": str(mcp_log_dest) if mcp_log_dest else None,
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"snapshot_project error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_check_kicad_ui(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Check if KiCAD UI is running.
|
|
|
|
`processes` is the single source of truth — `running` is derived from
|
|
its length so the two fields cannot disagree. Previously they came
|
|
from separate detection methods (pgrep regex vs. ps-aux substring) and
|
|
could race or use different filters, producing the confusing
|
|
`running=True, processes=[]` state users hit after quitting KiCAD.
|
|
"""
|
|
logger.info("Checking if KiCAD UI is running")
|
|
try:
|
|
manager = KiCADProcessManager()
|
|
# `processes` is the single source of truth (from #173) so
|
|
# `running` can't disagree with it; and if KiCAD is up, opportunistically
|
|
# (re)connect the IPC backend (#140) so a session that started before
|
|
# KiCAD launched can fall up from SWIG to IPC.
|
|
processes = manager.get_process_info()
|
|
is_running = len(processes) > 0
|
|
if is_running:
|
|
self._try_enable_ipc_backend()
|
|
|
|
return {
|
|
"success": True,
|
|
"running": is_running,
|
|
"processes": processes,
|
|
"message": "KiCAD is running" if is_running else "KiCAD is not running",
|
|
**self._backend_status(),
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error checking KiCAD UI status: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_launch_kicad_ui(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Launch KiCAD UI"""
|
|
logger.info("Launching KiCAD UI")
|
|
try:
|
|
project_path = params.get("projectPath")
|
|
auto_launch = params.get("autoLaunch", AUTO_LAUNCH_KICAD)
|
|
|
|
# Convert project path to Path object if provided
|
|
from pathlib import Path
|
|
|
|
path_obj = Path(project_path) if project_path else None
|
|
|
|
result = check_and_launch_kicad(path_obj, auto_launch)
|
|
if result.get("running"):
|
|
self._try_enable_ipc_backend(force=True)
|
|
|
|
return {"success": True, **result, **self._backend_status()}
|
|
except Exception as e:
|
|
logger.error(f"Error launching KiCAD UI: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_refill_zones(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Refill all copper pour zones on the board.
|
|
|
|
pcbnew.ZONE_FILLER.Fill() can cause a C++ access violation (0xC0000005)
|
|
that crashes the entire Python process when called from SWIG outside KiCAD UI.
|
|
To avoid killing the main process we run the fill in an isolated subprocess.
|
|
If the subprocess crashes or times out, we return a non-fatal warning so the
|
|
caller can continue — KiCAD Pcbnew will refill zones automatically when the
|
|
board is opened (press B).
|
|
"""
|
|
logger.info("Refilling zones (subprocess isolation)")
|
|
try:
|
|
if not self.board:
|
|
return {
|
|
"success": False,
|
|
"message": "No board is loaded",
|
|
"errorDetails": "Load or create a board first",
|
|
}
|
|
|
|
# First save the board so the subprocess can load it fresh
|
|
board_path = self.board.GetFileName()
|
|
if not board_path:
|
|
return {
|
|
"success": False,
|
|
"message": "Board has no file path — save first",
|
|
}
|
|
self.board.Save(board_path)
|
|
|
|
zone_count = self.board.GetAreaCount() if hasattr(self.board, "GetAreaCount") else 0
|
|
|
|
# Run pcbnew zone fill in an isolated subprocess to prevent crashes
|
|
import subprocess
|
|
import sys
|
|
import textwrap
|
|
|
|
script = textwrap.dedent(f"""
|
|
import pcbnew, sys
|
|
board = pcbnew.LoadBoard({repr(board_path)})
|
|
filler = pcbnew.ZONE_FILLER(board)
|
|
filler.Fill(board.Zones())
|
|
board.Save({repr(board_path)})
|
|
print("ok")
|
|
""")
|
|
try:
|
|
result = subprocess.run(
|
|
[sys.executable, "-c", script],
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=60,
|
|
)
|
|
if result.returncode == 0 and "ok" in result.stdout:
|
|
# Reload board after subprocess modified it
|
|
reloaded = self._safe_load_board(board_path)
|
|
if reloaded is None:
|
|
return {
|
|
"success": False,
|
|
"message": (
|
|
"Zone fill subprocess succeeded but the board "
|
|
"could not be reloaded into pcbnew (SWIG state "
|
|
"is corrupt — restart the MCP server)"
|
|
),
|
|
"zoneCount": zone_count,
|
|
}
|
|
self.board = reloaded
|
|
self._update_command_handlers()
|
|
logger.info("Zone fill subprocess succeeded")
|
|
return {
|
|
"success": True,
|
|
"message": f"Zones refilled successfully ({zone_count} zones)",
|
|
"zoneCount": zone_count,
|
|
}
|
|
else:
|
|
logger.warning(
|
|
f"Zone fill subprocess failed: rc={result.returncode} stderr={result.stderr[:200]}"
|
|
)
|
|
return {
|
|
"success": False,
|
|
"message": "Zone fill failed in subprocess — zones are defined and will fill when opened in KiCAD (press B). Continuing is safe.",
|
|
"zoneCount": zone_count,
|
|
"details": (result.stderr[:300] if result.stderr else result.stdout[:300]),
|
|
}
|
|
except subprocess.TimeoutExpired:
|
|
logger.warning("Zone fill subprocess timed out after 60s")
|
|
return {
|
|
"success": False,
|
|
"message": "Zone fill timed out — zones are defined and will fill when opened in KiCAD (press B). Continuing is safe.",
|
|
"zoneCount": zone_count,
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error refilling zones: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
# =========================================================================
|
|
# IPC Backend handlers - these provide real-time UI synchronization
|
|
# These methods are called automatically when IPC is available
|
|
# =========================================================================
|
|
|
|
def _ipc_route_trace(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for route_trace - adds track with real-time UI update"""
|
|
try:
|
|
# Extract parameters matching the existing route_trace interface
|
|
start = params.get("start", {})
|
|
end = params.get("end", {})
|
|
layer = params.get("layer", "F.Cu")
|
|
width = params.get("width", 0.25)
|
|
net = params.get("net")
|
|
|
|
# Handle both dict format and direct x/y
|
|
start_x = start.get("x", 0) if isinstance(start, dict) else params.get("startX", 0)
|
|
start_y = start.get("y", 0) if isinstance(start, dict) else params.get("startY", 0)
|
|
end_x = end.get("x", 0) if isinstance(end, dict) else params.get("endX", 0)
|
|
end_y = end.get("y", 0) if isinstance(end, dict) else params.get("endY", 0)
|
|
|
|
success = self.ipc_board_api.add_track(
|
|
start_x=start_x,
|
|
start_y=start_y,
|
|
end_x=end_x,
|
|
end_y=end_y,
|
|
width=width,
|
|
layer=layer,
|
|
net_name=net,
|
|
)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
"Added trace (visible in KiCAD UI)" if success else "Failed to add trace"
|
|
),
|
|
"trace": {
|
|
"start": {"x": start_x, "y": start_y, "unit": "mm"},
|
|
"end": {"x": end_x, "y": end_y, "unit": "mm"},
|
|
"layer": layer,
|
|
"width": width,
|
|
"net": net,
|
|
},
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC route_trace error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_route_arc_trace(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for route_arc_trace - adds copper arc with real-time UI update"""
|
|
try:
|
|
start = params.get("start", {})
|
|
mid = params.get("mid", {})
|
|
end = params.get("end", {})
|
|
layer = params.get("layer", "F.Cu")
|
|
width = params.get("width", 0.25)
|
|
net = params.get("net")
|
|
|
|
start_x = start.get("x", 0)
|
|
start_y = start.get("y", 0)
|
|
mid_x = mid.get("x", 0)
|
|
mid_y = mid.get("y", 0)
|
|
end_x = end.get("x", 0)
|
|
end_y = end.get("y", 0)
|
|
|
|
if not hasattr(self.ipc_board_api, "add_arc_track"):
|
|
return {
|
|
"success": False,
|
|
"message": "IPC backend does not support arc track on this installation",
|
|
}
|
|
|
|
success = self.ipc_board_api.add_arc_track(
|
|
start_x=start_x,
|
|
start_y=start_y,
|
|
mid_x=mid_x,
|
|
mid_y=mid_y,
|
|
end_x=end_x,
|
|
end_y=end_y,
|
|
width=width,
|
|
layer=layer,
|
|
net_name=net,
|
|
)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
"Added arc trace (visible in KiCAD UI)"
|
|
if success
|
|
else "Failed to add arc trace"
|
|
),
|
|
"arc": {
|
|
"start": {"x": start_x, "y": start_y, "unit": "mm"},
|
|
"mid": {"x": mid_x, "y": mid_y, "unit": "mm"},
|
|
"end": {"x": end_x, "y": end_y, "unit": "mm"},
|
|
"layer": layer,
|
|
"width": width,
|
|
"net": net,
|
|
},
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC route_arc_trace error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_add_via(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for add_via - adds via with real-time UI update"""
|
|
try:
|
|
position = params.get("position", {})
|
|
x = position.get("x", 0) if isinstance(position, dict) else params.get("x", 0)
|
|
y = position.get("y", 0) if isinstance(position, dict) else params.get("y", 0)
|
|
|
|
size = params.get("size", 0.8)
|
|
drill = params.get("drill", 0.4)
|
|
net = params.get("net")
|
|
from_layer = params.get("from_layer", "F.Cu")
|
|
to_layer = params.get("to_layer", "B.Cu")
|
|
|
|
success = self.ipc_board_api.add_via(
|
|
x=x, y=y, diameter=size, drill=drill, net_name=net, via_type="through"
|
|
)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": ("Added via (visible in KiCAD UI)" if success else "Failed to add via"),
|
|
"via": {
|
|
"position": {"x": x, "y": y, "unit": "mm"},
|
|
"size": size,
|
|
"drill": drill,
|
|
"from_layer": from_layer,
|
|
"to_layer": to_layer,
|
|
"net": net,
|
|
},
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC add_via error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_add_net(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for add_net"""
|
|
# Note: Net creation via IPC is limited - nets are typically created
|
|
# when components are placed. Return success for compatibility.
|
|
name = params.get("name")
|
|
logger.info(f"IPC add_net: {name} (nets auto-created with components)")
|
|
return {
|
|
"success": True,
|
|
"message": f"Net '{name}' will be created when components are connected",
|
|
"net": {"name": name},
|
|
}
|
|
|
|
def _ipc_add_copper_pour(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for add_copper_pour - adds zone with real-time UI update"""
|
|
try:
|
|
layer = params.get("layer", "F.Cu")
|
|
net = params.get("net")
|
|
clearance = params.get("clearance", 0.5)
|
|
min_width = params.get("minWidth", 0.25)
|
|
points = params.get("points", [])
|
|
priority = params.get("priority", 0)
|
|
fill_type = params.get("fillType", "solid")
|
|
name = params.get("name", "")
|
|
|
|
if not points or len(points) < 3:
|
|
return {
|
|
"success": False,
|
|
"message": "At least 3 points are required for copper pour outline",
|
|
}
|
|
|
|
# Convert points format if needed (handle both {x, y} and {x, y, unit})
|
|
formatted_points = []
|
|
for point in points:
|
|
formatted_points.append({"x": point.get("x", 0), "y": point.get("y", 0)})
|
|
|
|
success = self.ipc_board_api.add_zone(
|
|
points=formatted_points,
|
|
layer=layer,
|
|
net_name=net,
|
|
clearance=clearance,
|
|
min_thickness=min_width,
|
|
priority=priority,
|
|
fill_mode=fill_type,
|
|
name=name,
|
|
)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
"Added copper pour (visible in KiCAD UI)"
|
|
if success
|
|
else "Failed to add copper pour"
|
|
),
|
|
"pour": {
|
|
"layer": layer,
|
|
"net": net,
|
|
"clearance": clearance,
|
|
"minWidth": min_width,
|
|
"priority": priority,
|
|
"fillType": fill_type,
|
|
"pointCount": len(points),
|
|
},
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC add_copper_pour error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_refill_zones(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for refill_zones - refills all zones with real-time UI update"""
|
|
try:
|
|
success = self.ipc_board_api.refill_zones()
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
"Zones refilled (visible in KiCAD UI)" if success else "Failed to refill zones"
|
|
),
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC refill_zones error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_add_text(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for add_text/add_board_text - adds text with real-time UI update"""
|
|
try:
|
|
text = params.get("text", "")
|
|
position = params.get("position", {})
|
|
x = position.get("x", 0) if isinstance(position, dict) else params.get("x", 0)
|
|
y = position.get("y", 0) if isinstance(position, dict) else params.get("y", 0)
|
|
layer = params.get("layer", "F.SilkS")
|
|
size = params.get("size", 1.0)
|
|
rotation = params.get("rotation", 0)
|
|
|
|
success = self.ipc_board_api.add_text(
|
|
text=text, x=x, y=y, layer=layer, size=size, rotation=rotation
|
|
)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
f"Added text '{text}' (visible in KiCAD UI)"
|
|
if success
|
|
else "Failed to add text"
|
|
),
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC add_text error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_set_board_size(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for set_board_size"""
|
|
try:
|
|
width = params.get("width", 100)
|
|
height = params.get("height", 100)
|
|
unit = params.get("unit", "mm")
|
|
|
|
success = self.ipc_board_api.set_size(width, height, unit)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
f"Board size set to {width}x{height} {unit} (visible in KiCAD UI)"
|
|
if success
|
|
else "Failed to set board size"
|
|
),
|
|
"boardSize": {"width": width, "height": height, "unit": unit},
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC set_board_size error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_get_board_info(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for get_board_info"""
|
|
try:
|
|
size = self.ipc_board_api.get_size()
|
|
components = self.ipc_board_api.list_components()
|
|
tracks = self.ipc_board_api.get_tracks()
|
|
vias = self.ipc_board_api.get_vias()
|
|
nets = self.ipc_board_api.get_nets()
|
|
|
|
return {
|
|
"success": True,
|
|
"boardInfo": {
|
|
"size": size,
|
|
"componentCount": len(components),
|
|
"trackCount": len(tracks),
|
|
"viaCount": len(vias),
|
|
"netCount": len(nets),
|
|
"backend": "ipc",
|
|
"realtime": True,
|
|
},
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC get_board_info error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_place_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for place_component - places component with real-time UI update"""
|
|
try:
|
|
reference = params.get("reference", params.get("componentId", ""))
|
|
footprint = params.get("footprint", "")
|
|
position = params.get("position", {})
|
|
x = position.get("x", 0) if isinstance(position, dict) else params.get("x", 0)
|
|
y = position.get("y", 0) if isinstance(position, dict) else params.get("y", 0)
|
|
unit = position.get("unit", "mm") if isinstance(position, dict) else "mm"
|
|
rotation = params.get("rotation", 0)
|
|
layer = params.get("layer", "F.Cu")
|
|
value = params.get("value", "")
|
|
|
|
# Convert to mm since ipc_backend expects mm
|
|
if unit == "inch":
|
|
x = x * 25.4
|
|
y = y * 25.4
|
|
elif unit == "mil":
|
|
x = x * 0.0254
|
|
y = y * 0.0254
|
|
|
|
success = self.ipc_board_api.place_component(
|
|
reference=reference,
|
|
footprint=footprint,
|
|
x=x,
|
|
y=y,
|
|
rotation=rotation,
|
|
layer=layer,
|
|
value=value,
|
|
)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
f"Placed component {reference} (visible in KiCAD UI)"
|
|
if success
|
|
else "Failed to place component"
|
|
),
|
|
"component": {
|
|
"reference": reference,
|
|
"footprint": footprint,
|
|
"position": {"x": x, "y": y, "unit": "mm"},
|
|
"rotation": rotation,
|
|
"layer": layer,
|
|
},
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC place_component error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_move_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for move_component - moves component with real-time UI update"""
|
|
try:
|
|
reference = params.get("reference", params.get("componentId", ""))
|
|
position = params.get("position", {})
|
|
x = position.get("x", 0) if isinstance(position, dict) else params.get("x", 0)
|
|
y = position.get("y", 0) if isinstance(position, dict) else params.get("y", 0)
|
|
unit = position.get("unit", "mm") if isinstance(position, dict) else "mm"
|
|
rotation = params.get("rotation")
|
|
|
|
# Convert to mm since ipc_backend.move_component expects mm
|
|
if unit == "inch":
|
|
x = x * 25.4
|
|
y = y * 25.4
|
|
elif unit == "mil":
|
|
x = x * 0.0254
|
|
y = y * 0.0254
|
|
|
|
success = self.ipc_board_api.move_component(
|
|
reference=reference, x=x, y=y, rotation=rotation
|
|
)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
f"Moved component {reference} (visible in KiCAD UI)"
|
|
if success
|
|
else "Failed to move component"
|
|
),
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC move_component error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_delete_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for delete_component - deletes component with real-time UI update"""
|
|
try:
|
|
reference = params.get("reference", params.get("componentId", ""))
|
|
|
|
success = self.ipc_board_api.delete_component(reference=reference)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
f"Deleted component {reference} (visible in KiCAD UI)"
|
|
if success
|
|
else "Failed to delete component"
|
|
),
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC delete_component error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_get_component_list(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for get_component_list"""
|
|
try:
|
|
components = self.ipc_board_api.list_components()
|
|
|
|
# If IPC didn't provide bounding boxes, enrich from SWIG backend
|
|
if self.board and components and not components[0].get("boundingBox"):
|
|
try:
|
|
swig_result = self.component_commands.get_component_list(params)
|
|
if swig_result.get("success"):
|
|
swig_map = {c["reference"]: c for c in swig_result.get("components", [])}
|
|
for comp in components:
|
|
swig_comp = swig_map.get(comp.get("reference"))
|
|
if swig_comp and swig_comp.get("boundingBox"):
|
|
comp["boundingBox"] = swig_comp["boundingBox"]
|
|
except Exception:
|
|
pass
|
|
|
|
return {"success": True, "components": components, "count": len(components)}
|
|
except Exception as e:
|
|
logger.error(f"IPC get_component_list error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_save_project(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for save_project"""
|
|
try:
|
|
success = self.ipc_board_api.save()
|
|
|
|
return {
|
|
"success": success,
|
|
"message": "Project saved" if success else "Failed to save project",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC save_project error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_delete_trace(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for delete_trace - Note: IPC doesn't support direct trace deletion yet"""
|
|
# IPC API doesn't have a direct delete track method
|
|
# Fall back to SWIG for this operation
|
|
logger.info("delete_trace: Falling back to SWIG (IPC doesn't support trace deletion)")
|
|
return self.routing_commands.delete_trace(params)
|
|
|
|
def _ipc_query_traces(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for query_traces - reads traces from the live KiCAD board."""
|
|
try:
|
|
net_name = params.get("net")
|
|
layer_filter = params.get("layer")
|
|
bbox = params.get("boundingBox")
|
|
include_vias = params.get("includeVias", False)
|
|
|
|
def point_in_bbox(point: Dict[str, Any]) -> bool:
|
|
if not bbox:
|
|
return True
|
|
unit_scale = 25.4 if bbox.get("unit", "mm") == "inch" else 1.0
|
|
x1 = bbox.get("x1", 0) * unit_scale
|
|
y1 = bbox.get("y1", 0) * unit_scale
|
|
x2 = bbox.get("x2", 0) * unit_scale
|
|
y2 = bbox.get("y2", 0) * unit_scale
|
|
low_x, high_x = sorted((x1, x2))
|
|
low_y, high_y = sorted((y1, y2))
|
|
return low_x <= point.get("x", 0) <= high_x and low_y <= point.get("y", 0) <= high_y
|
|
|
|
traces = []
|
|
for track in self.ipc_board_api.get_tracks():
|
|
if net_name and track.get("net") != net_name:
|
|
continue
|
|
|
|
layer = self._normalize_ipc_layer_name(track.get("layer", ""))
|
|
if layer_filter and layer != layer_filter:
|
|
continue
|
|
|
|
start = track.get("start", {})
|
|
end = track.get("end", {})
|
|
if bbox and not (point_in_bbox(start) or point_in_bbox(end)):
|
|
continue
|
|
|
|
start_with_unit = {**start, "unit": "mm"}
|
|
end_with_unit = {**end, "unit": "mm"}
|
|
dx = end.get("x", 0) - start.get("x", 0)
|
|
dy = end.get("y", 0) - start.get("y", 0)
|
|
traces.append(
|
|
{
|
|
"uuid": track.get("id", ""),
|
|
"net": track.get("net", ""),
|
|
"netCode": track.get("netCode", 0),
|
|
"layer": layer,
|
|
"width": track.get("width", 0),
|
|
"start": start_with_unit,
|
|
"end": end_with_unit,
|
|
"length": (dx**2 + dy**2) ** 0.5,
|
|
}
|
|
)
|
|
|
|
result = {"success": True, "traceCount": len(traces), "traces": traces}
|
|
|
|
if include_vias:
|
|
vias = []
|
|
for via in self.ipc_board_api.get_vias():
|
|
if net_name and via.get("net") != net_name:
|
|
continue
|
|
position = via.get("position", {})
|
|
if bbox and not point_in_bbox(position):
|
|
continue
|
|
vias.append(
|
|
{
|
|
"uuid": via.get("id", ""),
|
|
"position": {**position, "unit": "mm"},
|
|
"net": via.get("net", ""),
|
|
"netCode": via.get("netCode", 0),
|
|
"diameter": via.get("diameter", 0),
|
|
"drill": via.get("drill", 0),
|
|
}
|
|
)
|
|
result["viaCount"] = len(vias)
|
|
result["vias"] = vias
|
|
|
|
return result
|
|
except Exception as e:
|
|
logger.error(f"IPC query_traces error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_get_nets_list(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for get_nets_list - gets nets with real-time data"""
|
|
try:
|
|
nets = self.ipc_board_api.get_nets()
|
|
|
|
return {"success": True, "nets": nets, "count": len(nets)}
|
|
except Exception as e:
|
|
logger.error(f"IPC get_nets_list error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_add_board_outline(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for add_board_outline - adds board edge with real-time UI update.
|
|
Rounded rectangles are delegated to the SWIG path because the IPC BoardSegment
|
|
type cannot represent arcs; the SWIG path writes directly to the .kicad_pcb file
|
|
and correctly generates PCB_SHAPE arcs for rounded corners.
|
|
"""
|
|
shape = params.get("shape", "rectangle")
|
|
if shape in ("rounded_rectangle", "rectangle"):
|
|
# IPC path only supports straight segments from a points list,
|
|
# but Claude sends rectangle/rounded_rectangle as shape+width+height.
|
|
# Fall back to the SWIG path which correctly handles both shapes.
|
|
logger.info(f"_ipc_add_board_outline: delegating {shape} to SWIG path")
|
|
return self.board_commands.add_board_outline(params)
|
|
|
|
try:
|
|
from kipy.board_types import BoardSegment
|
|
from kipy.geometry import Vector2
|
|
from kipy.proto.board.board_types_pb2 import BoardLayer
|
|
from kipy.util.units import from_mm
|
|
|
|
board = self.ipc_board_api._get_board()
|
|
|
|
# Unwrap nested params (Claude sends {"shape":..., "params":{...}})
|
|
inner = params.get("params", params)
|
|
points = inner.get("points", params.get("points", []))
|
|
width = inner.get("width", params.get("width", 0.1))
|
|
|
|
if len(points) < 2:
|
|
return {
|
|
"success": False,
|
|
"message": "At least 2 points required for board outline",
|
|
}
|
|
|
|
commit = board.begin_commit()
|
|
lines_created = 0
|
|
|
|
# Create line segments connecting the points
|
|
for i in range(len(points)):
|
|
start = points[i]
|
|
end = points[(i + 1) % len(points)] # Wrap around to close the outline
|
|
|
|
segment = BoardSegment()
|
|
segment.start = Vector2.from_xy(
|
|
from_mm(start.get("x", 0)), from_mm(start.get("y", 0))
|
|
)
|
|
segment.end = Vector2.from_xy(from_mm(end.get("x", 0)), from_mm(end.get("y", 0)))
|
|
segment.layer = BoardLayer.BL_Edge_Cuts
|
|
segment.attributes.stroke.width = from_mm(width)
|
|
|
|
board.create_items(segment)
|
|
lines_created += 1
|
|
|
|
board.push_commit(commit, "Added board outline")
|
|
|
|
return {
|
|
"success": True,
|
|
"message": f"Added board outline with {lines_created} segments (visible in KiCAD UI)",
|
|
"segments": lines_created,
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC add_board_outline error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_add_mounting_hole(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for add_mounting_hole - adds mounting hole with real-time UI update"""
|
|
try:
|
|
from kipy.board_types import BoardCircle
|
|
from kipy.geometry import Vector2
|
|
from kipy.proto.board.board_types_pb2 import BoardLayer
|
|
from kipy.util.units import from_mm
|
|
|
|
board = self.ipc_board_api._get_board()
|
|
|
|
x = params.get("x", 0)
|
|
y = params.get("y", 0)
|
|
diameter = params.get("diameter", 3.2) # M3 hole default
|
|
|
|
commit = board.begin_commit()
|
|
|
|
# Create circle on Edge.Cuts layer for the hole
|
|
circle = BoardCircle()
|
|
circle.center = Vector2.from_xy(from_mm(x), from_mm(y))
|
|
circle.radius = from_mm(diameter / 2) # type: ignore[assignment,method-assign]
|
|
circle.layer = BoardLayer.BL_Edge_Cuts
|
|
circle.attributes.stroke.width = from_mm(0.1)
|
|
|
|
board.create_items(circle)
|
|
board.push_commit(commit, f"Added mounting hole at ({x}, {y})")
|
|
|
|
return {
|
|
"success": True,
|
|
"message": f"Added mounting hole at ({x}, {y}) mm (visible in KiCAD UI)",
|
|
"hole": {"position": {"x": x, "y": y}, "diameter": diameter},
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC add_mounting_hole error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_get_layer_list(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for get_layer_list - gets enabled layers"""
|
|
try:
|
|
layers = self.ipc_board_api.get_enabled_layers()
|
|
|
|
return {"success": True, "layers": layers, "count": len(layers)}
|
|
except Exception as e:
|
|
logger.error(f"IPC get_layer_list error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_rotate_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for rotate_component - rotates component with real-time UI update"""
|
|
try:
|
|
reference = params.get("reference", params.get("componentId", ""))
|
|
angle = params.get("angle", params.get("rotation", 90))
|
|
|
|
# Get current component to find its position
|
|
components = self.ipc_board_api.list_components()
|
|
target = None
|
|
for comp in components:
|
|
if comp.get("reference") == reference:
|
|
target = comp
|
|
break
|
|
|
|
if not target:
|
|
return {"success": False, "message": f"Component {reference} not found"}
|
|
|
|
# Use angle as absolute rotation (matches schema description)
|
|
new_rotation = angle % 360
|
|
|
|
# Use move_component with new rotation (position stays the same)
|
|
success = self.ipc_board_api.move_component(
|
|
reference=reference,
|
|
x=target.get("position", {}).get("x", 0),
|
|
y=target.get("position", {}).get("y", 0),
|
|
rotation=new_rotation,
|
|
)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
f"Rotated component {reference} by {angle}° (visible in KiCAD UI)"
|
|
if success
|
|
else "Failed to rotate component"
|
|
),
|
|
"newRotation": new_rotation,
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC rotate_component error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_get_component_properties(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for get_component_properties - gets detailed component info"""
|
|
try:
|
|
reference = params.get("reference", params.get("componentId", ""))
|
|
|
|
components = self.ipc_board_api.list_components()
|
|
target = None
|
|
for comp in components:
|
|
if comp.get("reference") == reference:
|
|
target = comp
|
|
break
|
|
|
|
if not target:
|
|
return {"success": False, "message": f"Component {reference} not found"}
|
|
|
|
# If IPC didn't provide bounding box, try SWIG backend as fallback
|
|
if not target.get("boundingBox") and self.board:
|
|
try:
|
|
swig_result = self.component_commands.get_component_properties(params)
|
|
if swig_result.get("success"):
|
|
swig_comp = swig_result.get("component", {})
|
|
target["boundingBox"] = swig_comp.get("boundingBox")
|
|
target["courtyard"] = swig_comp.get("courtyard")
|
|
except Exception:
|
|
pass
|
|
|
|
return {"success": True, "component": target}
|
|
except Exception as e:
|
|
logger.error(f"IPC get_component_properties error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
# =========================================================================
|
|
# Legacy IPC command handlers (explicit ipc_* commands)
|
|
|
|
def _handle_warmup(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Force full pcbnew/wxApp initialisation.
|
|
|
|
On macOS the wxApp singleton is created lazily on the first
|
|
pcbnew operation that needs it (not on ``import pcbnew``).
|
|
That first call can take 55-65 s outside the KiCad GUI, which
|
|
exceeds the 30 s default MCP-client tool-call timeout.
|
|
|
|
This handler is called by the TypeScript server during startup
|
|
(with a 120 s timeout) so the cost is paid before any user
|
|
tools are registered with the MCP client.
|
|
"""
|
|
import time
|
|
|
|
start = time.monotonic()
|
|
try:
|
|
# pcbnew.BOARD() triggers wxApp creation on macOS.
|
|
# GetBuildVersion() alone is too cheap — it doesn't
|
|
# force the wxWidgets event loop to materialise.
|
|
board = pcbnew.BOARD()
|
|
del board
|
|
ver = pcbnew.GetBuildVersion()
|
|
elapsed = time.monotonic() - start
|
|
logger.info(f"Warm-up complete: pcbnew {ver} ({elapsed:.1f}s)")
|
|
return {"success": True, "version": ver, "elapsed_s": round(elapsed, 1)}
|
|
except Exception as exc:
|
|
elapsed = time.monotonic() - start
|
|
logger.error(f"Warm-up failed after {elapsed:.1f}s: {exc}")
|
|
return {"success": False, "message": str(exc), "elapsed_s": round(elapsed, 1)}
|
|
|
|
# =========================================================================
|
|
|
|
def _handle_get_backend_info(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Get information about the current backend"""
|
|
if KiCADProcessManager.is_running():
|
|
self._try_enable_ipc_backend()
|
|
status = self._backend_status()
|
|
ipc_backend = getattr(self, "ipc_backend", None)
|
|
return {
|
|
"success": True,
|
|
**status,
|
|
"version": ipc_backend.get_version() if ipc_backend else "N/A",
|
|
"message": (
|
|
"Using IPC backend with real-time UI sync"
|
|
if status["backend"] == "ipc"
|
|
else "Using SWIG backend (requires manual reload)"
|
|
),
|
|
}
|
|
|
|
def _handle_get_backend_state(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Return the MCP/KiCad backend state and currently loaded file state."""
|
|
if KiCADProcessManager.is_running():
|
|
self._try_enable_ipc_backend()
|
|
|
|
status = self._backend_status()
|
|
board_path = self._current_board_path()
|
|
project_path = self._current_project_file_path(board_path)
|
|
dirty_state = self._dirty_state(board_path)
|
|
loaded_board = board_path is not None
|
|
loaded_project = project_path is not None
|
|
|
|
return {
|
|
"success": True,
|
|
"backend": status["backend"],
|
|
"realtime": status["realtime_sync"],
|
|
"realtime_sync": status["realtime_sync"],
|
|
"ipcConnected": status["ipc_connected"],
|
|
"ipc_connected": status["ipc_connected"],
|
|
"loadedProject": loaded_project,
|
|
"loadedBoard": loaded_board,
|
|
"projectPath": project_path,
|
|
"boardPath": board_path,
|
|
"dirty": dirty_state["dirty"],
|
|
"dirtyReason": dirty_state["dirtyReason"],
|
|
"diskChangedExternally": dirty_state["diskChangedExternally"],
|
|
"message": (
|
|
f"{status['backend']} backend; "
|
|
f"{'board loaded' if loaded_board else 'no board loaded'}"
|
|
),
|
|
}
|
|
|
|
def _handle_ipc_add_track(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a track using IPC backend (real-time)"""
|
|
if not self.use_ipc or not self.ipc_board_api:
|
|
return {"success": False, "message": "IPC backend not available"}
|
|
|
|
try:
|
|
success = self.ipc_board_api.add_track(
|
|
start_x=params.get("startX", 0),
|
|
start_y=params.get("startY", 0),
|
|
end_x=params.get("endX", 0),
|
|
end_y=params.get("endY", 0),
|
|
width=params.get("width", 0.25),
|
|
layer=params.get("layer", "F.Cu"),
|
|
net_name=params.get("net"),
|
|
)
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
"Track added (visible in KiCAD UI)" if success else "Failed to add track"
|
|
),
|
|
"realtime": True,
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error adding track via IPC: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_ipc_add_via(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a via using IPC backend (real-time)"""
|
|
if not self.use_ipc or not self.ipc_board_api:
|
|
return {"success": False, "message": "IPC backend not available"}
|
|
|
|
try:
|
|
success = self.ipc_board_api.add_via(
|
|
x=params.get("x", 0),
|
|
y=params.get("y", 0),
|
|
diameter=params.get("diameter", 0.8),
|
|
drill=params.get("drill", 0.4),
|
|
net_name=params.get("net"),
|
|
via_type=params.get("type", "through"),
|
|
)
|
|
return {
|
|
"success": success,
|
|
"message": ("Via added (visible in KiCAD UI)" if success else "Failed to add via"),
|
|
"realtime": True,
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error adding via via IPC: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_ipc_add_text(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add text using IPC backend (real-time)"""
|
|
if not self.use_ipc or not self.ipc_board_api:
|
|
return {"success": False, "message": "IPC backend not available"}
|
|
|
|
try:
|
|
success = self.ipc_board_api.add_text(
|
|
text=params.get("text", ""),
|
|
x=params.get("x", 0),
|
|
y=params.get("y", 0),
|
|
layer=params.get("layer", "F.SilkS"),
|
|
size=params.get("size", 1.0),
|
|
rotation=params.get("rotation", 0),
|
|
)
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
"Text added (visible in KiCAD UI)" if success else "Failed to add text"
|
|
),
|
|
"realtime": True,
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error adding text via IPC: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_ipc_list_components(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List components using IPC backend"""
|
|
if not self.use_ipc or not self.ipc_board_api:
|
|
return {"success": False, "message": "IPC backend not available"}
|
|
|
|
try:
|
|
components = self.ipc_board_api.list_components()
|
|
return {"success": True, "components": components, "count": len(components)}
|
|
except Exception as e:
|
|
logger.error(f"Error listing components via IPC: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_ipc_get_tracks(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Get tracks using IPC backend"""
|
|
if not self.use_ipc or not self.ipc_board_api:
|
|
return {"success": False, "message": "IPC backend not available"}
|
|
|
|
try:
|
|
tracks = self.ipc_board_api.get_tracks()
|
|
return {"success": True, "tracks": tracks, "count": len(tracks)}
|
|
except Exception as e:
|
|
logger.error(f"Error getting tracks via IPC: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_ipc_get_vias(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Get vias using IPC backend"""
|
|
if not self.use_ipc or not self.ipc_board_api:
|
|
return {"success": False, "message": "IPC backend not available"}
|
|
|
|
try:
|
|
vias = self.ipc_board_api.get_vias()
|
|
return {"success": True, "vias": vias, "count": len(vias)}
|
|
except Exception as e:
|
|
logger.error(f"Error getting vias via IPC: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_ipc_save_board(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Save board using IPC backend"""
|
|
if not self.use_ipc or not self.ipc_board_api:
|
|
return {"success": False, "message": "IPC backend not available"}
|
|
|
|
try:
|
|
success = self.ipc_board_api.save()
|
|
return {
|
|
"success": success,
|
|
"message": "Board saved" if success else "Failed to save board",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error saving board via IPC: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
# JLCPCB API handlers
|
|
|
|
def _handle_download_jlcpcb_database(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Download the JLCPCB parts catalog from a prebuilt source (issue #199).
|
|
|
|
Layered strategy (see commands.jlcpcb_downloader): CDFER single-file
|
|
SQLite (primary, no 7z) -> yaqwsx split-7z (fallback) -> official JLCPCB
|
|
API (optional, if credentials set). Replaces the broken JLCSearch
|
|
offset-pagination download.
|
|
"""
|
|
from commands import jlcpcb_downloader
|
|
|
|
try:
|
|
force = params.get("force", False)
|
|
prefer_source = params.get("source") # optional: cdfer|yaqwsx|official
|
|
|
|
stats = self.jlcpcb_parts.get_database_stats()
|
|
if stats["total_parts"] > 0 and not force:
|
|
return {
|
|
"success": False,
|
|
"message": "Database already exists. Use force=true to re-download.",
|
|
"stats": stats,
|
|
}
|
|
|
|
# The prebuilt paths recreate jlcpcb_parts.db on disk, so the open
|
|
# manager connection must be released first (Windows file locking),
|
|
# then reopened on the freshly written database.
|
|
self.jlcpcb_parts.close()
|
|
|
|
result = jlcpcb_downloader.download_database(
|
|
force=force,
|
|
prefer_source=prefer_source,
|
|
progress=lambda msg: logger.info(msg),
|
|
)
|
|
|
|
# Reopen the manager on the new database regardless of outcome.
|
|
self.jlcpcb_parts = JLCPCBPartsManager()
|
|
|
|
if not result.get("success"):
|
|
return result
|
|
|
|
# Refresh counts from the reopened manager (authoritative).
|
|
stats = self.jlcpcb_parts.get_database_stats()
|
|
result["total_parts"] = stats["total_parts"]
|
|
result["basic_parts"] = stats["basic_parts"]
|
|
result["extended_parts"] = stats["extended_parts"]
|
|
result["db_path"] = stats["db_path"]
|
|
return result
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error downloading JLCPCB database: {e}", exc_info=True)
|
|
# Best-effort: ensure the manager is usable after a failure.
|
|
try:
|
|
self.jlcpcb_parts = JLCPCBPartsManager()
|
|
except Exception:
|
|
pass
|
|
return {
|
|
"success": False,
|
|
"message": f"Failed to download database: {str(e)}",
|
|
}
|
|
|
|
def _handle_search_jlcpcb_parts(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Search JLCPCB parts database"""
|
|
try:
|
|
query = params.get("query")
|
|
category = params.get("category")
|
|
package = params.get("package")
|
|
library_type = params.get("library_type", "All")
|
|
manufacturer = params.get("manufacturer")
|
|
in_stock = params.get("in_stock", True)
|
|
limit = params.get("limit", 20)
|
|
|
|
# Adjust library_type filter
|
|
if library_type == "All":
|
|
library_type = None
|
|
|
|
parts = self.jlcpcb_parts.search_parts(
|
|
query=query,
|
|
category=category,
|
|
package=package,
|
|
library_type=library_type,
|
|
manufacturer=manufacturer,
|
|
in_stock=in_stock,
|
|
limit=limit,
|
|
)
|
|
|
|
# Add price breaks and footprints to each part
|
|
for part in parts:
|
|
if part.get("price_json"):
|
|
try:
|
|
part["price_breaks"] = json.loads(part["price_json"])
|
|
except:
|
|
part["price_breaks"] = []
|
|
|
|
return {"success": True, "parts": parts, "count": len(parts)}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error searching JLCPCB parts: {e}", exc_info=True)
|
|
return {"success": False, "message": f"Search failed: {str(e)}"}
|
|
|
|
def _handle_get_jlcpcb_part(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Get detailed information for a specific JLCPCB part"""
|
|
try:
|
|
lcsc_number = params.get("lcsc_number")
|
|
if not lcsc_number:
|
|
return {"success": False, "message": "Missing lcsc_number parameter"}
|
|
|
|
part = self.jlcpcb_parts.get_part_info(lcsc_number)
|
|
if not part:
|
|
return {"success": False, "message": f"Part not found: {lcsc_number}"}
|
|
|
|
# Get suggested KiCAD footprints
|
|
footprints = self.jlcpcb_parts.map_package_to_footprint(part.get("package", ""))
|
|
|
|
return {"success": True, "part": part, "footprints": footprints}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error getting JLCPCB part: {e}", exc_info=True)
|
|
return {"success": False, "message": f"Failed to get part info: {str(e)}"}
|
|
|
|
def _handle_get_jlcpcb_database_stats(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Get statistics about JLCPCB database"""
|
|
try:
|
|
stats = self.jlcpcb_parts.get_database_stats()
|
|
return {"success": True, "stats": stats}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error getting database stats: {e}", exc_info=True)
|
|
return {"success": False, "message": f"Failed to get stats: {str(e)}"}
|
|
|
|
def _handle_suggest_jlcpcb_alternatives(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Suggest alternative JLCPCB parts"""
|
|
try:
|
|
lcsc_number = params.get("lcsc_number")
|
|
limit = params.get("limit", 5)
|
|
|
|
if not lcsc_number:
|
|
return {"success": False, "message": "Missing lcsc_number parameter"}
|
|
|
|
# Get original part for price comparison
|
|
original_part = self.jlcpcb_parts.get_part_info(lcsc_number)
|
|
reference_price = None
|
|
if original_part and original_part.get("price_breaks"):
|
|
try:
|
|
reference_price = float(original_part["price_breaks"][0].get("price", 0))
|
|
except:
|
|
pass
|
|
|
|
alternatives = self.jlcpcb_parts.suggest_alternatives(lcsc_number, limit)
|
|
|
|
# Add price breaks to alternatives
|
|
for part in alternatives:
|
|
if part.get("price_json"):
|
|
try:
|
|
part["price_breaks"] = json.loads(part["price_json"])
|
|
except:
|
|
part["price_breaks"] = []
|
|
|
|
return {
|
|
"success": True,
|
|
"alternatives": alternatives,
|
|
"reference_price": reference_price,
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error suggesting alternatives: {e}", exc_info=True)
|
|
return {
|
|
"success": False,
|
|
"message": f"Failed to suggest alternatives: {str(e)}",
|
|
}
|
|
|
|
def _handle_enrich_datasheets(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Enrich schematic Datasheet fields from LCSC numbers"""
|
|
try:
|
|
from pathlib import Path
|
|
|
|
schematic_path = params.get("schematic_path")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "Missing schematic_path parameter"}
|
|
dry_run = params.get("dry_run", False)
|
|
manager = DatasheetManager()
|
|
return manager.enrich_schematic(Path(schematic_path), dry_run=dry_run)
|
|
except Exception as e:
|
|
logger.error(f"Error enriching datasheets: {e}", exc_info=True)
|
|
return {
|
|
"success": False,
|
|
"message": f"Failed to enrich datasheets: {str(e)}",
|
|
}
|
|
|
|
def _handle_get_datasheet_url(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Return LCSC datasheet and product URLs for a part number"""
|
|
try:
|
|
lcsc = params.get("lcsc", "")
|
|
if not lcsc:
|
|
return {"success": False, "message": "Missing lcsc parameter"}
|
|
manager = DatasheetManager()
|
|
datasheet_url = manager.get_datasheet_url(lcsc)
|
|
product_url = manager.get_product_url(lcsc)
|
|
if not datasheet_url:
|
|
return {"success": False, "message": f"Invalid LCSC number: {lcsc}"}
|
|
norm = manager._normalize_lcsc(lcsc)
|
|
return {
|
|
"success": True,
|
|
"lcsc": norm,
|
|
"datasheet_url": datasheet_url,
|
|
"product_url": product_url,
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error getting datasheet URL: {e}", exc_info=True)
|
|
return {
|
|
"success": False,
|
|
"message": f"Failed to get datasheet URL: {str(e)}",
|
|
}
|
|
|
|
|
|
def _write_response(response_fd: Any, response: Any) -> None:
|
|
"""Write a JSON response to the original stdout fd.
|
|
|
|
All response output goes through this function so that stray C-level
|
|
writes from pcbnew (warnings, diagnostics) never corrupt the JSON
|
|
framing seen by the TypeScript host.
|
|
"""
|
|
payload = json.dumps(response) + "\n"
|
|
os.write(response_fd, payload.encode("utf-8"))
|
|
|
|
|
|
def main() -> None:
|
|
"""Main entry point"""
|
|
# --- Redirect stdout so pcbnew C++ noise never reaches the TS host ---
|
|
# Save the real stdout fd for our exclusive JSON response channel.
|
|
_response_fd = os.dup(1)
|
|
# Point fd 1 (C-level stdout) at stderr so that any printf / std::cout
|
|
# output from pcbnew or other C extensions is visible in logs but does
|
|
# NOT corrupt the JSON stream the TypeScript side is parsing.
|
|
os.dup2(2, 1)
|
|
# Also redirect Python-level stdout to stderr for the same reason.
|
|
sys.stdout = sys.stderr
|
|
|
|
logger.info("Starting KiCAD interface...")
|
|
interface = KiCADInterface()
|
|
# Signal to the TypeScript server that the stdin loop is live.
|
|
_write_response(_response_fd, {"type": "ready"})
|
|
|
|
try:
|
|
logger.info("Processing commands from stdin...")
|
|
# Process commands from stdin
|
|
for line in sys.stdin:
|
|
try:
|
|
# Parse command
|
|
logger.debug(f"Received input: {line.strip()}")
|
|
command_data = json.loads(line)
|
|
|
|
# Check if this is JSON-RPC 2.0 format
|
|
if "jsonrpc" in command_data and command_data["jsonrpc"] == "2.0":
|
|
logger.info("Detected JSON-RPC 2.0 format message")
|
|
method = command_data.get("method")
|
|
params = command_data.get("params", {})
|
|
request_id = command_data.get("id")
|
|
|
|
# Handle MCP protocol methods
|
|
if method == "initialize":
|
|
logger.info("Handling MCP initialize")
|
|
response = {
|
|
"jsonrpc": "2.0",
|
|
"id": request_id,
|
|
"result": {
|
|
"protocolVersion": "2025-06-18",
|
|
"capabilities": {
|
|
"tools": {"listChanged": True},
|
|
"resources": {
|
|
"subscribe": False,
|
|
"listChanged": True,
|
|
},
|
|
},
|
|
"serverInfo": {
|
|
"name": "kicad-mcp-server",
|
|
"title": "KiCAD PCB Design Assistant",
|
|
"version": "2.1.0-alpha",
|
|
},
|
|
"instructions": "AI-assisted PCB design with KiCAD. Use tools to create projects, design boards, place components, route traces, and export manufacturing files.",
|
|
},
|
|
}
|
|
elif method == "tools/list":
|
|
logger.info("Handling MCP tools/list")
|
|
# Return list of available tools with proper schemas
|
|
tools = []
|
|
for cmd_name in interface.command_routes.keys():
|
|
if cmd_name in TOOL_SCHEMAS:
|
|
# Enrich the existing schema with IPC annotation data
|
|
# (adds description/blocking hints where the schema lacks them)
|
|
tool_def = _annotation_loader.enrich_schema(
|
|
cmd_name, TOOL_SCHEMAS[cmd_name]
|
|
)
|
|
tools.append(tool_def)
|
|
else:
|
|
# Build a best-effort schema from IPC annotations
|
|
ann_desc = _annotation_loader.description(cmd_name)
|
|
if ann_desc:
|
|
logger.debug(f"Using IPC annotation for tool: {cmd_name}")
|
|
else:
|
|
logger.warning(f"No schema or annotation for tool: {cmd_name}")
|
|
tools.append(
|
|
_annotation_loader.enrich_schema(
|
|
cmd_name,
|
|
{
|
|
"name": cmd_name,
|
|
"description": ann_desc or f"KiCAD command: {cmd_name}",
|
|
"inputSchema": {
|
|
"type": "object",
|
|
"properties": {},
|
|
},
|
|
},
|
|
)
|
|
)
|
|
|
|
logger.info(f"Returning {len(tools)} tools")
|
|
response = {
|
|
"jsonrpc": "2.0",
|
|
"id": request_id,
|
|
"result": {"tools": tools},
|
|
}
|
|
elif method == "tools/call":
|
|
logger.info("Handling MCP tools/call")
|
|
tool_name = params.get("name")
|
|
tool_params = params.get("arguments", {})
|
|
|
|
# Execute the command
|
|
result = interface.handle_command(tool_name, tool_params)
|
|
|
|
response = {
|
|
"jsonrpc": "2.0",
|
|
"id": request_id,
|
|
"result": {"content": [{"type": "text", "text": json.dumps(result)}]},
|
|
}
|
|
elif method == "resources/list":
|
|
logger.info("Handling MCP resources/list")
|
|
# Return list of available resources
|
|
response = {
|
|
"jsonrpc": "2.0",
|
|
"id": request_id,
|
|
"result": {"resources": RESOURCE_DEFINITIONS},
|
|
}
|
|
elif method == "resources/read":
|
|
logger.info("Handling MCP resources/read")
|
|
resource_uri = params.get("uri")
|
|
|
|
if not resource_uri:
|
|
response = {
|
|
"jsonrpc": "2.0",
|
|
"id": request_id,
|
|
"error": {
|
|
"code": -32602,
|
|
"message": "Missing required parameter: uri",
|
|
},
|
|
}
|
|
else:
|
|
# Read the resource
|
|
resource_data = handle_resource_read(resource_uri, interface)
|
|
|
|
response = {
|
|
"jsonrpc": "2.0",
|
|
"id": request_id,
|
|
"result": resource_data,
|
|
}
|
|
else:
|
|
logger.error(f"Unknown JSON-RPC method: {method}")
|
|
response = {
|
|
"jsonrpc": "2.0",
|
|
"id": request_id,
|
|
"error": {
|
|
"code": -32601,
|
|
"message": f"Method not found: {method}",
|
|
},
|
|
}
|
|
else:
|
|
# Handle legacy custom format
|
|
logger.info("Detected custom format message")
|
|
command = command_data.get("command")
|
|
params = command_data.get("params", {})
|
|
|
|
if not command:
|
|
logger.error("Missing command field")
|
|
response = {
|
|
"success": False,
|
|
"message": "Missing command",
|
|
"errorDetails": "The command field is required",
|
|
}
|
|
else:
|
|
# Handle command
|
|
response = interface.handle_command(command, params)
|
|
|
|
# Send response via the clean fd (immune to pcbnew stdout noise)
|
|
logger.debug(f"Sending response: {response}")
|
|
_write_response(_response_fd, response)
|
|
|
|
except json.JSONDecodeError as e:
|
|
logger.error(f"Invalid JSON input: {str(e)}")
|
|
response = {
|
|
"success": False,
|
|
"message": "Invalid JSON input",
|
|
"errorDetails": str(e),
|
|
}
|
|
_write_response(_response_fd, response)
|
|
|
|
except KeyboardInterrupt:
|
|
logger.info("KiCAD interface stopped")
|
|
sys.exit(0)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Unexpected error: {str(e)}\n{traceback.format_exc()}")
|
|
sys.exit(1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|