solidworks-mcp-python 1.5.0__py3-none-any.whl

solidworks_mcp/utils/__init__.py

@@ -0,0 +1,9 @@
+"""Utilities for SolidWorks MCP Server."""
+
+from .logging import setup_logging
+from .validation import validate_environment
+
+__all__ = [
+    "setup_logging",
+    "validate_environment",
+]

solidworks_mcp/utils/feature_tree_classifier.py

@@ -0,0 +1,342 @@
+"""Helpers for classifying SolidWorks model families from feature-tree snapshots."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+_SHEET_METAL_TOKENS = (
+    "sheet-metal",
+    "sheet metal",
+    "base-flange",
+    "edge-flange",
+    "sketched bend",
+    "miter flange",
+    "hem",
+    "jog",
+    "unfold",
+    "fold",
+    "flatten",
+    "flat-pattern",
+)
+
+_ADVANCED_SOLID_TOKENS = (
+    "loft",
+    "boundary",
+    "sweep",
+    "shell",
+    "surface",
+    "split",
+    "combine",
+    "rib",
+    "dome",
+)
+
+_REVOLVE_TOKENS = (
+    "revolve",
+    "bossrevolve",
+    "boss-revolve",
+    "cutrevolve",
+    "cut-revolve",
+)
+
+_EXTRUDE_TOKENS = (
+    "extrude",
+    "boss-extrude",
+    "cut-extrude",
+    "bosscutextrude",
+    "featureextrusion",
+)
+
+_ASSEMBLY_TOKENS = ("mate", "component", "subassembly")
+_DRAWING_TOKENS = (
+    "sheet format",
+    "drawing view",
+    "section view",
+    "detail view",
+    "model view",
+)
+
+
+def _as_lower_text(value: Any) -> str:
+    """Build internal as lower text.
+
+    Args:
+        value (Any): The value value.
+
+    Returns:
+        str: The resulting text value.
+    """
+
+    return str(value or "").strip().lower()
+
+
+def _feature_text(feature: Mapping[str, Any]) -> str:
+    """Build internal feature text.
+
+    Args:
+        feature (Mapping[str, Any]): The feature value.
+
+    Returns:
+        str: The resulting text value.
+    """
+
+    name = _as_lower_text(feature.get("name"))
+    feature_type = _as_lower_text(feature.get("type"))
+    return f"{name} {feature_type}".strip()
+
+
+def _has_any(texts: list[str], tokens: tuple[str, ...]) -> bool:
+    """Build internal has any.
+
+    Args:
+        texts (list[str]): The texts value.
+        tokens (tuple[str, ...]): The tokens value.
+
+    Returns:
+        bool: True if any, otherwise False.
+    """
+
+    return any(token in text for token in tokens for text in texts)
+
+
+def _match_examples(
+    texts: list[str], tokens: tuple[str, ...], limit: int = 4
+) -> list[str]:
+    """Build internal match examples.
+
+    Args:
+        texts (list[str]): The texts value.
+        tokens (tuple[str, ...]): The tokens value.
+        limit (int): The limit value. Defaults to 4.
+
+    Returns:
+        list[str]: A list containing the resulting items.
+    """
+
+    matches: list[str] = []
+    for text in texts:
+        if any(token in text for token in tokens):
+            matches.append(text)
+        if len(matches) >= limit:
+            break
+    return matches
+
+
+def classify_feature_tree_snapshot(
+    model_info: Mapping[str, Any] | None,
+    features: list[Mapping[str, Any]] | None,
+) -> dict[str, Any]:
+    """Classify a model family from model-info and feature-tree snapshots.
+
+    The output is intentionally simple and explainable so agents can use it as a planning
+    primitive rather than as a black-box prediction.
+
+    Args:
+        model_info (Mapping[str, Any] | None): The model info value.
+        features (list[Mapping[str, Any]] | None): The features value.
+
+    Returns:
+        dict[str, Any]: A dictionary containing the resulting values.
+    """
+
+    feature_list = list(features or [])
+    feature_texts = [_feature_text(feature) for feature in feature_list]
+    document_type = _as_lower_text((model_info or {}).get("type")) or "unknown"
+
+    evidence: list[str] = []
+    warnings: list[str] = []
+    next_actions: list[str] = []
+
+    family = "unknown"
+    workflow = "inspect-more"
+    confidence = "low"
+    needs_vba = False
+
+    if document_type == "assembly" or _has_any(feature_texts, _ASSEMBLY_TOKENS):
+        family = "assembly"
+        workflow = "assembly-planning"
+        confidence = "high" if document_type == "assembly" else "medium"
+        evidence.append("Assembly document or mate/component evidence detected")
+        next_actions.extend(
+            [
+                "List components and mates before planning inserts or edits",
+                "Delegate part-level reconstruction for each component separately",
+            ]
+        )
+    elif document_type == "drawing" or _has_any(feature_texts, _DRAWING_TOKENS):
+        family = "drawing"
+        workflow = "drawing-review"
+        confidence = "high" if document_type == "drawing" else "medium"
+        evidence.append("Drawing document or drawing-view evidence detected")
+        next_actions.append("Use drawing tools instead of part-modeling tools")
+    elif _has_any(feature_texts, _SHEET_METAL_TOKENS):
+        family = "sheet_metal"
+        workflow = "vba-sheet-metal"
+        confidence = "high"
+        needs_vba = True
+        evidence.extend(
+            _match_examples(feature_texts, _SHEET_METAL_TOKENS)
+            or ["Sheet metal features detected in the tree"]
+        )
+        next_actions.extend(
+            [
+                "Preserve base-flange and bend dependency order",
+                "If cuts appear between Unfold and Fold, keep them in flat-pattern state",
+                "Prefer a VBA-aware reconstruction plan until direct sheet metal tools exist",
+            ]
+        )
+    elif _has_any(feature_texts, _ADVANCED_SOLID_TOKENS):
+        family = "advanced_solid"
+        workflow = "vba-advanced-solid"
+        confidence = "medium"
+        needs_vba = True
+        evidence.extend(
+            _match_examples(feature_texts, _ADVANCED_SOLID_TOKENS)
+            or ["Advanced solid or surface features detected"]
+        )
+        next_actions.extend(
+            [
+                "Plan around loft/sweep/shell boundaries before issuing build commands",
+                "Prefer macro-backed execution for unsupported direct-MCP features",
+            ]
+        )
+    elif _has_any(feature_texts, _REVOLVE_TOKENS):
+        family = "revolve"
+        workflow = "direct-mcp-revolve"
+        confidence = "high"
+        evidence.extend(
+            _match_examples(feature_texts, _REVOLVE_TOKENS)
+            or ["Revolve features detected"]
+        )
+        next_actions.extend(
+            [
+                "Locate the axis sketch or centerline before recreating the profile",
+                "Verify the half-profile closes on the revolve axis",
+            ]
+        )
+    elif _has_any(feature_texts, _EXTRUDE_TOKENS):
+        family = "extrude"
+        workflow = "direct-mcp-extrude"
+        confidence = "high"
+        evidence.extend(
+            _match_examples(feature_texts, _EXTRUDE_TOKENS)
+            or ["Extrude features detected"]
+        )
+        next_actions.extend(
+            [
+                "Read the driving sketch before recreating downstream cuts or fillets",
+                "Verify closed-loop profiles before extrusion",
+            ]
+        )
+    else:
+        non_reference_count = 0
+        sketch_like_count = 0
+        for feature in feature_list:
+            feature_type = _as_lower_text(feature.get("type"))
+            if feature_type and feature_type not in {
+                "refplane",
+                "originprofilefeature",
+            }:
+                non_reference_count += 1
+            if feature_type in {"profilefeature", "3dprofilefeature", "sketch"}:
+                sketch_like_count += 1
+
+        if sketch_like_count > 0 and sketch_like_count == non_reference_count:
+            family = "sketch_only"
+            workflow = "inspect-more"
+            confidence = "low"
+            evidence.append("Only sketch-like features were found in the tree snapshot")
+            warnings.append(
+                "Feature tree may be incomplete for this adapter/runtime; do not infer the 3D family from sketches alone"
+            )
+            next_actions.extend(
+                [
+                    "Combine feature-tree output with mass properties and exported images",
+                    "Prefer reading the original file in SolidWorks before planning a rebuild",
+                ]
+            )
+        else:
+            warnings.append(
+                "No strong feature-family evidence found; keep planning provisional"
+            )
+            next_actions.extend(
+                [
+                    "Inspect more of the model state before building",
+                    "Avoid committing to direct-MCP or VBA-only paths until evidence improves",
+                ]
+            )
+
+    return {
+        "document_type": document_type or "unknown",
+        "family": family,
+        "recommended_workflow": workflow,
+        "confidence": confidence,
+        "needs_vba": needs_vba,
+        "evidence": evidence,
+        "warnings": warnings,
+        "next_actions": next_actions,
+        "feature_count": len(feature_list),
+    }
+
+
+def build_component_tree(features: list[Mapping[str, Any]] | None) -> dict[str, Any]:
+    """Reconstruct a nested component/sub-component tree from a flat
+    ``list_features`` result.
+
+    ``list_features`` returns a single flat list — see
+    ``openspec/changes/archive/2026-10-30-assembly-aware-list-features/design.md`` for why:
+    several existing callers (feature-tree diffing, feature-family
+    classification, the MCP tool's ``count`` field) assume
+    ``AdapterResult.data`` is a flat ``list[dict]`` unconditionally, so the
+    adapter contract stays flat. Each descriptor carries ``component``
+    (owning component, or ``None`` for the document's own features) and
+    ``component_parent`` (that component's immediate parent component, or
+    ``None`` for a top-level component), which is enough to rebuild the
+    tree a caller actually wants to *look at* without changing what the
+    adapter returns.
+
+    Args:
+        features: The flat list returned in an ``AdapterResult.data`` from
+            ``list_features``. Rows without a ``component_parent`` key
+            (older data, or non-component rows) are treated as top-level.
+
+    Returns:
+        dict[str, Any]: ``{"features": [...], "components": {name: {"path":
+        ..., "features": [...], "components": {...nested...}}}}``. For a
+        Part document (no rows carry a ``component``), this is just
+        ``{"features": [...all rows...], "components": {}}``.
+    """
+    rows = list(features or [])
+
+    own_features = [dict(r) for r in rows if r.get("component") is None]
+    root: dict[str, Any] = {"features": own_features, "components": {}}
+
+    nodes: dict[str, dict[str, Any]] = {}
+    parent_of: dict[str, str | None] = {}
+
+    for row in rows:
+        component = row.get("component")
+        if component is None:
+            continue
+        node = nodes.setdefault(
+            component,
+            {"path": row.get("component_path"), "features": [], "components": {}},
+        )
+        if row.get("type") not in ("UnresolvedComponent", "Component"):
+            node["features"].append(dict(row))
+        if row.get("component_path") and not node.get("path"):
+            node["path"] = row["component_path"]
+        parent = row.get("component_parent")
+        if parent is not None or component not in parent_of:
+            parent_of[component] = parent
+
+    for name, node in nodes.items():
+        parent = parent_of.get(name)
+        parent_node = nodes.get(parent) if parent else None
+        target = (
+            parent_node["components"] if parent_node is not None else root["components"]
+        )
+        target[name] = node
+
+    return root

solidworks_mcp/utils/logging.py

@@ -0,0 +1,76 @@
+"""Logging configuration for SolidWorks MCP Server."""
+
+import sys
+from pathlib import Path
+from typing import Any
+
+from loguru import logger
+
+from ..config import SolidWorksMCPConfig
+
+
+def setup_logging(config: SolidWorksMCPConfig) -> None:
+    """Configure application and audit logging sinks.
+
+    Args:
+        config (SolidWorksMCPConfig): Configuration values for the operation.
+
+    Returns:
+        None: None.
+    """
+    # Remove default handler
+    logger.remove()
+
+    # Console logging
+    logger.add(
+        sys.stderr,
+        level=config.log_level,
+        format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | "
+        "<level>{level: <8}</level> | "
+        "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> | "
+        "<level>{message}</level>",
+        colorize=True,
+    )
+
+    # File logging
+    if config.log_file:
+        # Ensure log directory exists
+        config.log_file.parent.mkdir(parents=True, exist_ok=True)
+
+        logger.add(
+            config.log_file,
+            level=config.log_level,
+            format="{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {name}:{function}:{line} | {message}",
+            rotation="10 MB",
+            retention="1 week",
+        )
+
+    # Audit logging for security
+    if config.enable_audit_logging:
+        audit_log = (
+            config.log_file.parent / "audit.log"
+            if config.log_file
+            else Path("audit.log")
+        )
+        audit_log.parent.mkdir(parents=True, exist_ok=True)
+
+        logger.add(
+            audit_log,
+            level="INFO",
+            format="{time:YYYY-MM-DD HH:mm:ss} | AUDIT | {extra[audit_type]} | {message}",
+            filter=lambda record: "audit" in record["extra"],
+            rotation="1 day",
+            retention="30 days",
+            compression="gz",
+        )
+
+    logger.info("Logging configured")
+
+
+def get_audit_logger() -> Any:
+    """Create a logger bound to audit metadata.
+
+    Returns:
+        Any: The result produced by the operation.
+    """
+    return logger.bind(audit=True)

solidworks_mcp/utils/validation.py

@@ -0,0 +1,77 @@
+"""Environment validation for SolidWorks MCP Server."""
+
+import platform
+import shutil
+
+from loguru import logger
+
+from ..config import SolidWorksMCPConfig
+from ..exceptions import SolidWorksMCPError
+
+
+async def validate_environment(config: SolidWorksMCPConfig) -> None:
+    """Validate runtime prerequisites for the server.
+
+    Args:
+        config (SolidWorksMCPConfig): Configuration values for the operation.
+
+    Returns:
+        None: None.
+
+    Raises:
+        SolidWorksMCPError: If the operation cannot be completed.
+    """
+    logger.info("Validating environment...")
+
+    # Check platform
+    if not config.can_use_solidworks and not config.mock_solidworks:
+        if platform.system() != "Windows":
+            logger.warning("SolidWorks requires Windows platform. Using mock adapter.")
+        else:
+            logger.warning("SolidWorks not available. Using mock adapter.")
+
+    # Check SolidWorks installation if on Windows
+    if (
+        config.enable_windows_validation
+        and platform.system() == "Windows"
+        and not config.mock_solidworks
+    ):
+        await _validate_solidworks_installation(config)
+
+    # Check Python version
+    import sys
+
+    python_version = sys.version_info
+    if python_version < (3, 13):
+        raise SolidWorksMCPError(
+            f"Python 3.13+ required, but running {python_version.major}.{python_version.minor}"
+        )
+
+    logger.info("Environment validation complete")
+
+
+async def _validate_solidworks_installation(config: SolidWorksMCPConfig) -> None:
+    """Validate SolidWorks availability on Windows hosts.
+
+    Args:
+        config (SolidWorksMCPConfig): Configuration values for the operation.
+
+    Returns:
+        None: None.
+    """
+    # Check if SolidWorks executable exists
+    if config.solidworks_path:
+        if not shutil.which(config.solidworks_path):
+            logger.warning(
+                f"SolidWorks executable not found at: {config.solidworks_path}"
+            )
+
+    # Check COM registration only. Resolving the ProgID reads the registry;
+    # creating the object (Dispatch) would start SolidWorks.
+    try:
+        import pywintypes
+
+        pywintypes.IID("SldWorks.Application")
+        logger.info("SolidWorks COM interface is available")
+    except Exception as e:
+        logger.warning(f"SolidWorks COM interface issue: {e}")

solidworks_mcp/version.py

@@ -0,0 +1,8 @@
+"""Version information for SolidWorks MCP Server."""
+
+__version__ = "1.5.0"
+__author__ = "Andrew Bartels"
+__email__ = "andrewbartels1@gmail.com"
+__description__ = "SolidWorks MCP Server with FastMCP and PydanticAI"
+__original_author__ = "Vinnie Esposito"
+__license__ = "MIT"