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

solidworks_mcp/ui/routers/__init__.py

@@ -0,0 +1,10 @@
+"""FastAPI router for the ``routers`` sub-package.
+
+Import individual routers and include them in the FastAPI app:
+
+.. code-block:: python
+
+    from solidworks_mcp.ui.routers import session, model, preview, llm, checkpoint, docs, viewer
+    app.include_router(session.router)
+    ...
+"""

solidworks_mcp/ui/routers/checkpoint.py

@@ -0,0 +1,24 @@
+"""Checkpoint execution route for the Prefab CAD dashboard."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from ..services import DEFAULT_SESSION_ID, execute_next_checkpoint
+
+router = APIRouter()
+
+
+class CheckpointExecuteRequest(BaseModel):
+    """Request payload for checkpoint execution."""
+
+    session_id: str = DEFAULT_SESSION_ID
+
+
+@router.post("/api/ui/checkpoints/execute-next")
+async def execute_checkpoint(payload: CheckpointExecuteRequest) -> dict[str, Any]:
+    """Execute the next pending design checkpoint against the SolidWorks adapter."""
+    return await execute_next_checkpoint(payload.session_id)

solidworks_mcp/ui/routers/docs.py

@@ -0,0 +1,47 @@
+"""Docs context and RAG ingestion routes for the Prefab CAD dashboard."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from ..services import DEFAULT_SESSION_ID, fetch_docs_context, ingest_reference_source
+
+router = APIRouter()
+
+
+class DocsContextRequest(BaseModel):
+    """Request payload for docs-context refresh."""
+
+    session_id: str = DEFAULT_SESSION_ID
+    query: str = "SolidWorks MCP endpoints"
+
+
+class RagIngestRequest(BaseModel):
+    """Request payload for BYO retrieval ingestion from a local path or URL."""
+
+    session_id: str = DEFAULT_SESSION_ID
+    source_path: str
+    namespace: str = "engineering-reference"
+    chunk_size: int = 1200
+    overlap: int = 200
+
+
+@router.post("/api/ui/docs/context")
+async def docs_context(payload: DocsContextRequest) -> dict[str, Any]:
+    """Fetch and cache docs text from the /docs endpoint."""
+    return fetch_docs_context(payload.session_id, docs_query=payload.query)
+
+
+@router.post("/api/ui/rag/ingest")
+async def rag_ingest(payload: RagIngestRequest) -> dict[str, Any]:
+    """Ingest a local file or URL into the local retrieval index."""
+    return ingest_reference_source(
+        payload.session_id,
+        source_path=payload.source_path,
+        namespace=payload.namespace,
+        chunk_size=payload.chunk_size,
+        overlap=payload.overlap,
+    )

solidworks_mcp/ui/routers/llm.py

@@ -0,0 +1,83 @@
+"""LLM clarify / inspect / go-orchestration routes for the Prefab CAD dashboard."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from ...agents.history_db import get_design_session
+from ..services import (
+    DEFAULT_SESSION_ID,
+    DEFAULT_USER_GOAL,
+    inspect_family,
+    request_clarifications,
+    run_go_orchestration,
+)
+
+router = APIRouter()
+
+
+def _resolve_user_goal(session_id: str, user_goal: str) -> str:
+    """Prefer the approved session goal when the client sends the default placeholder."""
+
+    if user_goal and user_goal != DEFAULT_USER_GOAL:
+        return user_goal
+
+    session_row = get_design_session(session_id) or {}
+    return str(session_row.get("user_goal") or DEFAULT_USER_GOAL)
+
+
+class ClarifyWithAnswerRequest(BaseModel):
+    """Request payload for clarify that includes the user's typed answers."""
+
+    session_id: str = DEFAULT_SESSION_ID
+    user_goal: str = DEFAULT_USER_GOAL
+    user_answer: str = ""
+
+
+class GoOrchestrationRequest(BaseModel):
+    """Request payload for global Go orchestration action."""
+
+    session_id: str = DEFAULT_SESSION_ID
+    user_goal: str = DEFAULT_USER_GOAL
+    assumptions_text: str | None = None
+    user_answer: str = ""
+
+
+class FamilyInspectRequest(BaseModel):
+    """Request payload for design family classification."""
+
+    session_id: str = DEFAULT_SESSION_ID
+    user_goal: str = DEFAULT_USER_GOAL
+
+
+@router.post("/api/ui/clarify")
+async def clarify(payload: ClarifyWithAnswerRequest) -> dict[str, Any]:
+    """Call the LLM to generate clarifying questions for the design goal."""
+    return await request_clarifications(
+        payload.session_id,
+        user_goal=_resolve_user_goal(payload.session_id, payload.user_goal),
+        user_answer=payload.user_answer,
+    )
+
+
+@router.post("/api/ui/family/inspect")
+async def family_inspect(payload: FamilyInspectRequest) -> dict[str, Any]:
+    """Call the LLM to classify the design family from the current goal."""
+    return await inspect_family(
+        payload.session_id,
+        user_goal=_resolve_user_goal(payload.session_id, payload.user_goal),
+    )
+
+
+@router.post("/api/ui/orchestrate/go")
+async def orchestrate_go(payload: GoOrchestrationRequest) -> dict[str, Any]:
+    """Run the full Go orchestration pipeline (clarify → inspect → plan checkpoints)."""
+    return await run_go_orchestration(
+        payload.session_id,
+        user_goal=_resolve_user_goal(payload.session_id, payload.user_goal),
+        assumptions_text=payload.assumptions_text,
+        user_answer=payload.user_answer,
+    )

solidworks_mcp/ui/routers/local_model.py

@@ -0,0 +1,69 @@
+"""Local Ollama model probe / pull / query routes for the Prefab CAD dashboard."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+from ..local_llm import (
+    LocalAgentResult,
+    LocalModelProbeResult,
+    LocalModelPullRequest,
+    LocalModelPullResult,
+    LocalModelQueryRequest,
+)
+
+router = APIRouter()
+
+
+@router.get("/api/ui/local-model/probe")
+async def probe_local_model_endpoint() -> LocalModelProbeResult:
+    """Probe for a running Ollama server and recommend the best Gemma model tier."""
+    from ..local_llm import probe_local_model  # noqa: PLC0415
+
+    return await probe_local_model()
+
+
+@router.post("/api/ui/local-model/pull")
+async def pull_local_model_endpoint(
+    payload: LocalModelPullRequest,
+) -> LocalModelPullResult:
+    """Trigger an Ollama pull for the specified model name."""
+    from ..local_llm import pull_ollama_model  # noqa: PLC0415
+
+    return await pull_ollama_model(model=payload.model, endpoint=payload.endpoint)
+
+
+@router.post("/api/ui/local-model/query")
+async def query_local_model_endpoint(
+    payload: LocalModelQueryRequest,
+) -> LocalAgentResult:
+    """Run a free-form prompt against the local Ollama model."""
+    from pydantic import BaseModel as _BaseModel
+
+    from ..local_llm import LocalLLMConfig, run_local_agent  # noqa: PLC0415
+
+    class _FreeFormResponse(_BaseModel):
+        text: str
+
+    config = LocalLLMConfig.from_env()
+    if payload.endpoint:
+        config = config.model_copy(
+            update={
+                "endpoint": payload.endpoint,
+                "openai_endpoint": f"{payload.endpoint}/v1",
+            }
+        )
+    if payload.model:
+        service_model = (
+            payload.model
+            if payload.model.startswith("local:")
+            else f"local:{payload.model}"
+        )
+        config = config.model_copy(update={"service_model": service_model})
+
+    return await run_local_agent(
+        system_prompt=payload.system_prompt,
+        user_prompt=payload.prompt,
+        result_type=_FreeFormResponse,
+        config=config,
+    )

solidworks_mcp/ui/routers/model.py

@@ -0,0 +1,75 @@
+"""Model open/connect routes for the Prefab CAD dashboard."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter
+from pydantic import BaseModel, field_validator
+
+from ..services import (
+    DEFAULT_SESSION_ID,
+    connect_target_model,
+    open_target_model,
+)
+
+router = APIRouter()
+
+
+class UploadedFilePayload(BaseModel):
+    """Browser-uploaded file payload returned by Prefab's OpenFilePicker action."""
+
+    name: str
+    size: int
+    type: str
+    data: str
+
+
+class ConnectTargetModelRequest(BaseModel):
+    """Request payload for attaching an active SolidWorks target model."""
+
+    session_id: str = DEFAULT_SESSION_ID
+    model_path: str | None = None
+    uploaded_files: list[UploadedFilePayload] | None = None
+    feature_target_text: str | None = None
+
+    @field_validator("uploaded_files", mode="before")
+    @classmethod
+    def _coerce_empty_uploaded_files(cls, v: object) -> object:
+        """Coerce empty string or empty list to None so Pydantic accepts it."""
+        if v == "" or v == []:
+            return None
+        return v
+
+
+class OpenTargetModelRequest(BaseModel):
+    """Request payload for opening a target model by file path."""
+
+    session_id: str = DEFAULT_SESSION_ID
+    model_path: str | None = None
+    feature_target_text: str | None = None
+
+
+@router.post("/api/ui/model/connect")
+async def connect_model(payload: ConnectTargetModelRequest) -> dict[str, Any]:
+    """Attach a target SolidWorks document and derive grounded feature-tree context."""
+    return await connect_target_model(
+        payload.session_id,
+        model_path=payload.model_path,
+        uploaded_files=(
+            [f.model_dump() for f in payload.uploaded_files]
+            if payload.uploaded_files
+            else None
+        ),
+        feature_target_text=payload.feature_target_text,
+    )
+
+
+@router.post("/api/ui/model/open")
+async def open_model(payload: OpenTargetModelRequest) -> dict[str, Any]:
+    """Open a SolidWorks model by path and reflect its feature tree into the session."""
+    return await open_target_model(
+        payload.session_id,
+        model_path=payload.model_path,
+        feature_target_text=payload.feature_target_text,
+    )

solidworks_mcp/ui/routers/preview.py

@@ -0,0 +1,38 @@
+"""Preview and feature-highlight routes for the Prefab CAD dashboard."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from ..services import DEFAULT_SESSION_ID, highlight_feature, refresh_preview
+
+router = APIRouter()
+
+
+class PreviewRefreshRequest(BaseModel):
+    """Request payload for preview refresh requests."""
+
+    session_id: str = DEFAULT_SESSION_ID
+    orientation: str = "current"
+
+
+class FeatureSelectRequest(BaseModel):
+    """Request payload for highlighting a named feature in the SolidWorks model tree."""
+
+    session_id: str = DEFAULT_SESSION_ID
+    feature_name: str
+
+
+@router.post("/api/ui/preview/refresh")
+async def preview_refresh(payload: PreviewRefreshRequest) -> dict[str, Any]:
+    """Export the current SolidWorks viewport to a PNG/GLB preview."""
+    return await refresh_preview(payload.session_id, orientation=payload.orientation)
+
+
+@router.post("/api/ui/feature/select")
+async def feature_select(payload: FeatureSelectRequest) -> dict[str, Any]:
+    """Select and highlight a named feature in the active SolidWorks model."""
+    return await highlight_feature(payload.session_id, payload.feature_name)

solidworks_mcp/ui/routers/session.py

@@ -0,0 +1,161 @@
+"""Session management routes for the Prefab CAD dashboard.
+
+Covers: state hydration, debug snapshot, brief approval, preferences,
+workflow selection, notes, context save/load, family accept, and manual-sync reconcile.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Query
+from pydantic import BaseModel
+
+from ..services import (
+    DEFAULT_API_ORIGIN,
+    DEFAULT_SESSION_ID,
+    DEFAULT_USER_GOAL,
+    accept_family_choice,
+    approve_design_brief,
+    build_dashboard_state,
+    build_dashboard_trace_payload,
+    load_session_context,
+    reconcile_manual_edits,
+    save_session_context,
+    select_workflow_mode,
+    update_session_notes,
+    update_ui_preferences,
+)
+
+router = APIRouter()
+
+
+# ---------------------------------------------------------------------------
+# Request models
+# ---------------------------------------------------------------------------
+
+
+class SessionRequest(BaseModel):
+    """Base request payload containing session scope."""
+
+    session_id: str = DEFAULT_SESSION_ID
+
+
+class GoalRequest(SessionRequest):
+    """Request payload for endpoints that operate on the current design goal."""
+
+    user_goal: str = DEFAULT_USER_GOAL
+
+
+class FamilyAcceptRequest(SessionRequest):
+    """Request payload for family acceptance."""
+
+    family: str | None = None
+
+
+class PreferencesUpdateRequest(SessionRequest):
+    """Request payload for assumptions and model preference updates."""
+
+    assumptions_text: str
+    model_provider: str = "github"
+    model_profile: str = "balanced"
+    model_name: str | None = None
+    local_endpoint: str | None = None
+
+
+class WorkflowSelectionRequest(SessionRequest):
+    """Request payload for selecting the onboarding workflow branch."""
+
+    workflow_mode: str
+
+
+class NotesUpdateRequest(SessionRequest):
+    """Request payload for saving free-form engineering notes."""
+
+    notes_text: str = ""
+
+
+class ContextSaveRequest(SessionRequest):
+    """Request payload for saving context to a plain JSON snapshot."""
+
+    context_name: str | None = None
+
+
+class ContextLoadRequest(SessionRequest):
+    """Request payload for loading context snapshot from plain JSON."""
+
+    context_file: str | None = None
+
+
+# ---------------------------------------------------------------------------
+# Routes
+# ---------------------------------------------------------------------------
+
+
+@router.get("/api/ui/state")
+async def get_state(session_id: str = Query(DEFAULT_SESSION_ID)) -> dict[str, Any]:
+    """Hydrate UI state from active session database."""
+    return build_dashboard_state(session_id, api_origin=DEFAULT_API_ORIGIN)
+
+
+@router.get("/api/ui/debug/session")
+async def get_debug_session(
+    session_id: str = Query(DEFAULT_SESSION_ID),
+) -> dict[str, Any]:
+    """Return a verbose debug snapshot for the active UI session."""
+    return build_dashboard_trace_payload(session_id, api_origin=DEFAULT_API_ORIGIN)
+
+
+@router.post("/api/ui/brief/approve")
+async def approve_brief(payload: GoalRequest) -> dict[str, Any]:
+    """Accept the user-provided design goal."""
+    return approve_design_brief(payload.session_id, payload.user_goal)
+
+
+@router.post("/api/ui/preferences/update")
+async def update_preferences(payload: PreferencesUpdateRequest) -> dict[str, Any]:
+    """Persist assumptions and provider/model preferences in session metadata."""
+    return update_ui_preferences(
+        payload.session_id,
+        assumptions_text=payload.assumptions_text,
+        model_provider=payload.model_provider,
+        model_profile=payload.model_profile,
+        model_name=payload.model_name,
+        local_endpoint=payload.local_endpoint,
+    )
+
+
+@router.post("/api/ui/workflow/select")
+async def update_workflow_mode(payload: WorkflowSelectionRequest) -> dict[str, Any]:
+    """Persist the workflow choice shown on the opening dashboard screen."""
+    return select_workflow_mode(payload.session_id, workflow_mode=payload.workflow_mode)
+
+
+@router.post("/api/ui/family/accept")
+async def accept_family(payload: FamilyAcceptRequest) -> dict[str, Any]:
+    """Accept the proposed design family classification."""
+    return accept_family_choice(payload.session_id, family=payload.family)
+
+
+@router.post("/api/ui/notes/update")
+async def update_notes(payload: NotesUpdateRequest) -> dict[str, Any]:
+    """Persist free-form engineering notes for the session."""
+    return update_session_notes(payload.session_id, notes_text=payload.notes_text)
+
+
+@router.post("/api/ui/context/save")
+async def context_save(payload: ContextSaveRequest) -> dict[str, Any]:
+    """Save current session context to a JSON snapshot file."""
+    return save_session_context(payload.session_id, context_name=payload.context_name)
+
+
+@router.post("/api/ui/context/load")
+async def context_load(payload: ContextLoadRequest) -> dict[str, Any]:
+    """Load a previously saved session context JSON snapshot."""
+    return load_session_context(payload.session_id, context_file=payload.context_file)
+
+
+@router.post("/api/ui/manual-sync/reconcile")
+async def reconcile_edits(payload: SessionRequest) -> dict[str, Any]:
+    """Detect manual edits via snapshot diff and apply forward delta."""
+    return reconcile_manual_edits(payload.session_id)

solidworks_mcp/ui/routers/viewer.py

@@ -0,0 +1,154 @@
+"""Three.js 3D model viewer route for the Prefab CAD dashboard.
+
+# TODO: move _VIEWER_HTML to a Jinja2 template file at templates/viewer.html
+"""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Path
+from fastapi.responses import HTMLResponse
+
+router = APIRouter()
+
+# ---------------------------------------------------------------------------
+# Embedded Three.js viewer HTML
+# ---------------------------------------------------------------------------
+# TODO: move to templates/viewer.html and serve via Jinja2TemplateResponse
+_VIEWER_HTML = """\
+<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>3D Model Viewer</title>
+<style>
+* { margin: 0; padding: 0; box-sizing: border-box; }
+body { background: #0f172a; color: #94a3b8; font-family: system-ui, sans-serif; overflow: hidden; }
+#wrap { width: 100vw; height: 100vh; }
+#overlay { position: fixed; inset: 0; display: flex; flex-direction: column;
+    align-items: center; justify-content: center; gap: 10px; pointer-events: none; }
+#status { font-size: 13px; text-align: center; max-width: 300px; line-height: 1.6; }
+#hint { position: fixed; bottom: 10px; left: 50%; transform: translateX(-50%);
+    font-size: 11px; opacity: 0.35; user-select: none; }
+#fmt-badge { position: fixed; top: 8px; right: 10px; font-size: 10px;
+    opacity: 0.4; letter-spacing: 0.05em; user-select: none; }
+</style></head><body>
+<div id="wrap"></div>
+<div id="overlay">
+    <div id="icon" style="font-size:28px">&#9203;</div>
+    <div id="status">Loading 3D model&#8230;</div>
+</div>
+<div id="hint">Drag to rotate &middot; Scroll to zoom &middot; Right-drag to pan</div>
+<div id="fmt-badge"></div>
+<script type="importmap">{"imports": {
+    "three": "https://cdn.jsdelivr.net/npm/three@0.165.0/build/three.module.js",
+    "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.165.0/examples/jsm/"
+}}</script>
+<script type="module">
+import * as THREE from 'three';
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+import { STLLoader } from 'three/addons/loaders/STLLoader.js';
+
+const params = new URLSearchParams(location.search);
+const pathParts = location.pathname.split('/').filter(Boolean);
+const pathSessionId = pathParts[pathParts.length - 1] || 'prefab-dashboard';
+const sessionId = params.get('session_id') || pathSessionId;
+const ts = params.get('t') || '0';
+const fmt = params.get('fmt') || 'stl';
+
+const renderer = new THREE.WebGLRenderer({ antialias: true });
+renderer.setPixelRatio(window.devicePixelRatio);
+renderer.outputColorSpace = THREE.SRGBColorSpace;
+renderer.setSize(window.innerWidth, window.innerHeight);
+document.getElementById('wrap').appendChild(renderer.domElement);
+
+const scene = new THREE.Scene();
+scene.background = new THREE.Color(0x0f172a);
+
+const camera = new THREE.PerspectiveCamera(45, window.innerWidth / window.innerHeight, 0.01, 100000);
+camera.position.set(0, 100, 250);
+
+const controls = new OrbitControls(camera, renderer.domElement);
+controls.enableDamping = true;
+controls.dampingFactor = 0.06;
+
+scene.add(new THREE.AmbientLight(0xffffff, 0.8));
+const dirLight = new THREE.DirectionalLight(0xffffff, 1.2);
+dirLight.position.set(1, 2, 1.5);
+scene.add(dirLight);
+const fillLight = new THREE.DirectionalLight(0x8ab4f8, 0.4);
+fillLight.position.set(-1, -1, -1);
+scene.add(fillLight);
+
+const stlMaterial = new THREE.MeshPhongMaterial({
+    color: 0x3b82f6, specular: 0x1e3a5f, shininess: 60, side: THREE.DoubleSide
+});
+
+function fitCamera(object) {
+    const box = new THREE.Box3().setFromObject(object);
+    const size = box.getSize(new THREE.Vector3());
+    const center = box.getCenter(new THREE.Vector3());
+    const maxDim = Math.max(size.x, size.y, size.z) || 100;
+    camera.position.set(center.x, center.y + maxDim * 0.6, center.z + maxDim * 2);
+    camera.near = maxDim * 0.001;
+    camera.far = maxDim * 200;
+    camera.updateProjectionMatrix();
+    controls.target.copy(center);
+    controls.update();
+}
+
+function hideOverlay() { document.getElementById('overlay').style.display = 'none'; }
+function showError(msg) {
+    document.getElementById('icon').textContent = '( )';
+    document.getElementById('status').textContent = msg;
+}
+function onProgress(p) {
+    const pct = p.total ? Math.round(p.loaded / p.total * 100) : 0;
+    document.getElementById('status').textContent = 'Loading\\u2026 ' + pct + '%';
+}
+
+if (fmt === 'glb') {
+    document.getElementById('fmt-badge').textContent = 'GLB';
+    const glbUrl = location.origin + '/previews/' + sessionId + '.glb?_t=' + ts;
+    new GLTFLoader().load(glbUrl, (gltf) => {
+        hideOverlay();
+        const model = gltf.scene;
+        model.traverse((node) => {
+            if (node.isMesh && node.material) {
+                const mats = Array.isArray(node.material) ? node.material : [node.material];
+                mats.forEach((m) => { m.side = THREE.DoubleSide; });
+            }
+        });
+        scene.add(model);
+        fitCamera(model);
+    }, onProgress, () => showError('No 3D model file yet. Attach a SolidWorks model, then click Refresh 3D View.'));
+} else if (fmt === 'stl') {
+    document.getElementById('fmt-badge').textContent = 'STL';
+    const stlUrl = location.origin + '/previews/' + sessionId + '.stl?_t=' + ts;
+    new STLLoader().load(stlUrl, (geometry) => {
+        hideOverlay();
+        geometry.computeBoundingBox();
+        geometry.center();
+        geometry.computeVertexNormals();
+        const mesh = new THREE.Mesh(geometry, stlMaterial);
+        scene.add(mesh);
+        fitCamera(mesh);
+    }, onProgress, () => showError('No 3D model file yet. Attach a SolidWorks model, then click Refresh 3D View.'));
+} else {
+    showError('No 3D model file yet. Attach a SolidWorks model, then click Refresh 3D View.');
+}
+
+window.addEventListener('resize', () => {
+    camera.aspect = window.innerWidth / window.innerHeight;
+    camera.updateProjectionMatrix();
+    renderer.setSize(window.innerWidth, window.innerHeight);
+});
+(function animate() { requestAnimationFrame(animate); controls.update(); renderer.render(scene, camera); })();
+</script></body></html>
+"""
+
+
+@router.get("/api/ui/viewer/{session_id}", response_class=HTMLResponse)
+async def get_viewer(
+    session_id: str = Path(description="Session identifier for 3D model file routing"),
+) -> HTMLResponse:
+    """Serve the embedded Three.js 3D model viewer page."""
+    return HTMLResponse(content=_VIEWER_HTML, media_type="text/html")