cadcore-ai 0.1.0__tar.gz

cadcore_ai-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kukil Kashyap Borgohain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cadcore_ai-0.1.0/PKG-INFO

@@ -0,0 +1,265 @@
+Metadata-Version: 2.4
+Name: cadcore-ai
+Version: 0.1.0
+Summary: Standalone Agentic Python CAD generation pipeline
+Author: Kukil Kashyap Borgohain
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/kXborg/CadCore
+Project-URL: Repository, https://github.com/kXborg/CadCore
+Project-URL: Issues, https://github.com/kXborg/CadCore/issues
+Project-URL: Documentation, https://github.com/kXborg/CadCore#readme
+Keywords: cad,build123d,freecad,agentic-ai,text-to-cad,3d-printing,opencascade
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Manufacturing
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: build123d>=0.8.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Requires-Dist: jinja2>=3.1.0
+Provides-Extra: llm
+Requires-Dist: google-genai>=0.1.0; extra == "llm"
+Requires-Dist: openai>=1.0.0; extra == "llm"
+Requires-Dist: anthropic>=0.18.0; extra == "llm"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: trimesh>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# CadCore
+
+CadCore is a standalone agentic pipeline that translates natural language descriptions into parametric 3D CAD models (`.step`, `.stl`), 2D technical drawings (`.svg`), and interactive 3D Web Viewers (`.html`) with an automated self-healing execution loop.
+
+---
+
+## Architecture
+
+```mermaid
+flowchart TD
+    User("User Prompt<br/>(Natural Language)") --> LLM("LLM Planner & Coder<br/>(Gemini / OpenAI / Anthropic / Ollama)")
+    LLM --> Code("Generated Parametric Script<br/>(build123d / FreeCAD)")
+    Code --> Sandbox("Subprocess Sandbox Executor")
+    Sandbox --> Validate{"Execution & Solid Validation"}
+    
+    Validate -- "Error / Invalid Solid" --> Heal("Self-Healing Feedback<br/>(Traceback + Code Context)")
+    Heal -->|"Retry (Up to max_retries)"| LLM
+    
+    Validate -- "Success" --> Exporter("Multi-Format Exporter")
+    
+    Exporter --> STEP("model.step<br/>(Standard B-Rep CAD)")
+    Exporter --> STL("model.stl<br/>(3D Printing Mesh)")
+    Exporter --> SVG("drawing.svg<br/>(2D Technical Drawing)")
+    Exporter --> HTML("viewer.html<br/>(Interactive 3D Web Viewer)")
+    Exporter --> META("cadcore_meta.json<br/>(Metrics & Metadata)")
+
+    classDef prompt fill:#1e293b,stroke:#38bdf8,stroke-width:2px,color:#f8fafc;
+    classDef llm fill:#1e1b4b,stroke:#818cf8,stroke-width:2px,color:#f8fafc;
+    classDef script fill:#0f172a,stroke:#94a3b8,stroke-width:2px,color:#f8fafc;
+    classDef decision fill:#172554,stroke:#60a5fa,stroke-width:2px,color:#f8fafc;
+    classDef healing fill:#451a03,stroke:#f59e0b,stroke-width:2px,color:#f8fafc;
+    classDef exporter fill:#064e3b,stroke:#10b981,stroke-width:2px,color:#f8fafc;
+    classDef artifact fill:#0c4a6e,stroke:#38bdf8,stroke-width:1.5px,color:#f8fafc;
+
+    class User prompt;
+    class LLM llm;
+    class Code,Sandbox script;
+    class Validate decision;
+    class Heal healing;
+    class Exporter exporter;
+    class STEP,STL,SVG,HTML,META artifact;
+```
+
+---
+
+## Key Features
+
+* **Multi-Backend CAD Support**:
+  * **`build123d` (Default)**: Modern OpenCASCADE-based Pythonic CAD engine. Fast, headless, and runs in pure Python.
+  * **`freecad`**: Executes native FreeCAD scripts headlessly via `FreeCADCmd`.
+* **Pluggable LLM Providers**: Built-in support for Google Gemini (`google-genai`), OpenAI / Ollama (`openai`), Anthropic (`anthropic`), and offline `mock` testing.
+* **Self-Healing Loop**: Captures runtime errors, missing imports, or invalid topology, then sends tracebacks back to the LLM for automatic correction.
+* **Multi-Format Export**: Generates STEP files for CAD exchange, STL meshes for 3D printing, SVG for 2D engineering drawings, and standalone HTML 3D viewers.
+* **Geometric Validation**: Analyzes exported meshes for volume, bounding box dimensions, and watertight manifold status.
+
+---
+
+## Installation
+
+### Prerequisites
+* Python 3.10, 3.11, or 3.12 (Python 3.11 recommended).
+* Optional: FreeCAD 0.20+ if using the FreeCAD backend.
+
+### 1. From PyPI
+
+```bash
+pip install cadcore-ai
+```
+
+### 2. From Source
+
+```bash
+# Clone repository
+git clone https://github.com/kXborg/CadCore.git
+cd CadCore
+
+# Create and activate virtual environment
+python -m venv .venv
+.\.venv\Scripts\activate     # On Windows
+# source .venv/bin/activate  # On Linux/macOS
+
+# Install dependencies in editable mode
+pip install -e .
+```
+
+---
+
+## Configuration
+
+Set API keys via environment variables according to your provider:
+
+```bash
+# Google Gemini (Default)
+export GEMINI_API_KEY="your-gemini-key"
+
+# OpenAI / Compatible
+export OPENAI_API_KEY="your-openai-key"
+
+# Anthropic
+export ANTHROPIC_API_KEY="your-anthropic-key"
+
+# Ollama / Local LLM (Optional URL override)
+export OLLAMA_BASE_URL="http://localhost:11434/v1"
+```
+
+---
+
+## CLI Usage
+
+CadCore provides a CLI interface through `cadcore` or `python -m cadcore`.
+
+### 1. Check Supported Backends
+```bash
+python -m cadcore list-backends
+```
+
+### 2. Generate a CAD Part
+```bash
+python -m cadcore generate "NEMA 17 stepper motor mount plate 42x42mm with central 22mm hole and 4 corner M3 holes at 31mm spacing" --output ./outputs/nema17
+```
+
+### 3. Generate and Open Interactive 3D Viewer
+```bash
+python -m cadcore generate "L-bracket 50x50x25mm with 4mm thickness and 2 M5 mounting holes on each leg" --output ./outputs/l_bracket --view
+```
+
+### 4. CLI Options Reference
+```text
+Arguments:
+  PROMPT                       Natural language description of the CAD model.
+
+Options:
+  -o, --output PATH            Directory to save generated artifacts. [default: ./output]
+  -b, --backend [build123d|freecad]
+                               CAD engine backend. [default: build123d]
+  -p, --provider [gemini|openai|anthropic|ollama|mock]
+                               LLM Provider. [default: gemini]
+  -m, --model TEXT             LLM model identifier override.
+  -r, --retries INTEGER        Maximum self-healing retry attempts. [default: 3]
+  -v, --view                   Open 3D interactive viewer in browser upon completion.
+```
+
+---
+
+## Python API Usage
+
+CadCore can be embedded directly into Python workflows:
+
+```python
+from pathlib import Path
+from cadcore.config import PipelineConfig, CADBackendType, LLMConfig, LLMProvider
+from cadcore.pipeline import CADAgentPipeline
+
+# Configure pipeline
+config = PipelineConfig(
+    backend=CADBackendType.BUILD123D,
+    output_dir=Path("./outputs/flange"),
+    max_retries=2,
+    export_step=True,
+    export_stl=True,
+    export_svg=True,
+    generate_viewer=True,
+    llm=LLMConfig(
+        provider=LLMProvider.GEMINI,
+        model="gemini-2.5-flash",
+    ),
+)
+
+# Run pipeline
+pipeline = CADAgentPipeline(config)
+result = pipeline.run("Round pipe flange 60mm OD, 30mm ID, 8mm thickness with 4 bolt holes of 5mm diameter")
+
+if result.success:
+    print(f"Generated successfully in {result.execution_time_seconds:.2f}s ({result.iterations} attempt(s))")
+    print(f"STEP: {result.artifacts['model.step']}")
+    print(f"STL:  {result.artifacts['model.stl']}")
+    print(f"SVG:  {result.artifacts['drawing.svg']}")
+    print(f"3D Viewer: {result.artifacts['viewer.html']}")
+    print(f"Volume: {result.metrics.get('volume_mm3')} mm³")
+else:
+    print(f"Generation failed: {result.error_message}")
+```
+
+---
+
+## Repository Structure
+
+```
+CadCore/
+├── cadcore/
+│   ├── __init__.py
+│   ├── __main__.py          # Entrypoint for python -m cadcore
+│   ├── cli.py               # Typer & Rich CLI
+│   ├── config.py            # Configuration & provider settings
+│   ├── executor.py          # Subprocess sandbox & trimesh validation
+│   ├── pipeline.py          # Orchestrator & self-healing loop
+│   ├── viewer.py            # Three.js 3D/2D HTML viewer generator
+│   ├── backends/
+│   │   ├── base.py          # Abstract CADBackend
+│   │   ├── build123d_backend.py
+│   │   └── freecad_backend.py
+│   └── llm/
+│       ├── client.py        # Pluggable LLM clients
+│       └── prompts.py       # CAD prompts & few-shot examples
+├── examples/
+│   └── basic_pipeline_demo.py
+├── tests/
+│   └── test_pipeline.py
+├── pyproject.toml
+├── requirements.txt
+└── README.md
+```
+
+---
+
+## Testing
+
+Run the test suite with `pytest`:
+
+```bash
+pytest tests/ -v
+```
+
+---
+
+## License
+
+MIT License.

cadcore_ai-0.1.0/README.md

@@ -0,0 +1,228 @@
+# CadCore
+
+CadCore is a standalone agentic pipeline that translates natural language descriptions into parametric 3D CAD models (`.step`, `.stl`), 2D technical drawings (`.svg`), and interactive 3D Web Viewers (`.html`) with an automated self-healing execution loop.
+
+---
+
+## Architecture
+
+```mermaid
+flowchart TD
+    User("User Prompt<br/>(Natural Language)") --> LLM("LLM Planner & Coder<br/>(Gemini / OpenAI / Anthropic / Ollama)")
+    LLM --> Code("Generated Parametric Script<br/>(build123d / FreeCAD)")
+    Code --> Sandbox("Subprocess Sandbox Executor")
+    Sandbox --> Validate{"Execution & Solid Validation"}
+    
+    Validate -- "Error / Invalid Solid" --> Heal("Self-Healing Feedback<br/>(Traceback + Code Context)")
+    Heal -->|"Retry (Up to max_retries)"| LLM
+    
+    Validate -- "Success" --> Exporter("Multi-Format Exporter")
+    
+    Exporter --> STEP("model.step<br/>(Standard B-Rep CAD)")
+    Exporter --> STL("model.stl<br/>(3D Printing Mesh)")
+    Exporter --> SVG("drawing.svg<br/>(2D Technical Drawing)")
+    Exporter --> HTML("viewer.html<br/>(Interactive 3D Web Viewer)")
+    Exporter --> META("cadcore_meta.json<br/>(Metrics & Metadata)")
+
+    classDef prompt fill:#1e293b,stroke:#38bdf8,stroke-width:2px,color:#f8fafc;
+    classDef llm fill:#1e1b4b,stroke:#818cf8,stroke-width:2px,color:#f8fafc;
+    classDef script fill:#0f172a,stroke:#94a3b8,stroke-width:2px,color:#f8fafc;
+    classDef decision fill:#172554,stroke:#60a5fa,stroke-width:2px,color:#f8fafc;
+    classDef healing fill:#451a03,stroke:#f59e0b,stroke-width:2px,color:#f8fafc;
+    classDef exporter fill:#064e3b,stroke:#10b981,stroke-width:2px,color:#f8fafc;
+    classDef artifact fill:#0c4a6e,stroke:#38bdf8,stroke-width:1.5px,color:#f8fafc;
+
+    class User prompt;
+    class LLM llm;
+    class Code,Sandbox script;
+    class Validate decision;
+    class Heal healing;
+    class Exporter exporter;
+    class STEP,STL,SVG,HTML,META artifact;
+```
+
+---
+
+## Key Features
+
+* **Multi-Backend CAD Support**:
+  * **`build123d` (Default)**: Modern OpenCASCADE-based Pythonic CAD engine. Fast, headless, and runs in pure Python.
+  * **`freecad`**: Executes native FreeCAD scripts headlessly via `FreeCADCmd`.
+* **Pluggable LLM Providers**: Built-in support for Google Gemini (`google-genai`), OpenAI / Ollama (`openai`), Anthropic (`anthropic`), and offline `mock` testing.
+* **Self-Healing Loop**: Captures runtime errors, missing imports, or invalid topology, then sends tracebacks back to the LLM for automatic correction.
+* **Multi-Format Export**: Generates STEP files for CAD exchange, STL meshes for 3D printing, SVG for 2D engineering drawings, and standalone HTML 3D viewers.
+* **Geometric Validation**: Analyzes exported meshes for volume, bounding box dimensions, and watertight manifold status.
+
+---
+
+## Installation
+
+### Prerequisites
+* Python 3.10, 3.11, or 3.12 (Python 3.11 recommended).
+* Optional: FreeCAD 0.20+ if using the FreeCAD backend.
+
+### 1. From PyPI
+
+```bash
+pip install cadcore-ai
+```
+
+### 2. From Source
+
+```bash
+# Clone repository
+git clone https://github.com/kXborg/CadCore.git
+cd CadCore
+
+# Create and activate virtual environment
+python -m venv .venv
+.\.venv\Scripts\activate     # On Windows
+# source .venv/bin/activate  # On Linux/macOS
+
+# Install dependencies in editable mode
+pip install -e .
+```
+
+---
+
+## Configuration
+
+Set API keys via environment variables according to your provider:
+
+```bash
+# Google Gemini (Default)
+export GEMINI_API_KEY="your-gemini-key"
+
+# OpenAI / Compatible
+export OPENAI_API_KEY="your-openai-key"
+
+# Anthropic
+export ANTHROPIC_API_KEY="your-anthropic-key"
+
+# Ollama / Local LLM (Optional URL override)
+export OLLAMA_BASE_URL="http://localhost:11434/v1"
+```
+
+---
+
+## CLI Usage
+
+CadCore provides a CLI interface through `cadcore` or `python -m cadcore`.
+
+### 1. Check Supported Backends
+```bash
+python -m cadcore list-backends
+```
+
+### 2. Generate a CAD Part
+```bash
+python -m cadcore generate "NEMA 17 stepper motor mount plate 42x42mm with central 22mm hole and 4 corner M3 holes at 31mm spacing" --output ./outputs/nema17
+```
+
+### 3. Generate and Open Interactive 3D Viewer
+```bash
+python -m cadcore generate "L-bracket 50x50x25mm with 4mm thickness and 2 M5 mounting holes on each leg" --output ./outputs/l_bracket --view
+```
+
+### 4. CLI Options Reference
+```text
+Arguments:
+  PROMPT                       Natural language description of the CAD model.
+
+Options:
+  -o, --output PATH            Directory to save generated artifacts. [default: ./output]
+  -b, --backend [build123d|freecad]
+                               CAD engine backend. [default: build123d]
+  -p, --provider [gemini|openai|anthropic|ollama|mock]
+                               LLM Provider. [default: gemini]
+  -m, --model TEXT             LLM model identifier override.
+  -r, --retries INTEGER        Maximum self-healing retry attempts. [default: 3]
+  -v, --view                   Open 3D interactive viewer in browser upon completion.
+```
+
+---
+
+## Python API Usage
+
+CadCore can be embedded directly into Python workflows:
+
+```python
+from pathlib import Path
+from cadcore.config import PipelineConfig, CADBackendType, LLMConfig, LLMProvider
+from cadcore.pipeline import CADAgentPipeline
+
+# Configure pipeline
+config = PipelineConfig(
+    backend=CADBackendType.BUILD123D,
+    output_dir=Path("./outputs/flange"),
+    max_retries=2,
+    export_step=True,
+    export_stl=True,
+    export_svg=True,
+    generate_viewer=True,
+    llm=LLMConfig(
+        provider=LLMProvider.GEMINI,
+        model="gemini-2.5-flash",
+    ),
+)
+
+# Run pipeline
+pipeline = CADAgentPipeline(config)
+result = pipeline.run("Round pipe flange 60mm OD, 30mm ID, 8mm thickness with 4 bolt holes of 5mm diameter")
+
+if result.success:
+    print(f"Generated successfully in {result.execution_time_seconds:.2f}s ({result.iterations} attempt(s))")
+    print(f"STEP: {result.artifacts['model.step']}")
+    print(f"STL:  {result.artifacts['model.stl']}")
+    print(f"SVG:  {result.artifacts['drawing.svg']}")
+    print(f"3D Viewer: {result.artifacts['viewer.html']}")
+    print(f"Volume: {result.metrics.get('volume_mm3')} mm³")
+else:
+    print(f"Generation failed: {result.error_message}")
+```
+
+---
+
+## Repository Structure
+
+```
+CadCore/
+├── cadcore/
+│   ├── __init__.py
+│   ├── __main__.py          # Entrypoint for python -m cadcore
+│   ├── cli.py               # Typer & Rich CLI
+│   ├── config.py            # Configuration & provider settings
+│   ├── executor.py          # Subprocess sandbox & trimesh validation
+│   ├── pipeline.py          # Orchestrator & self-healing loop
+│   ├── viewer.py            # Three.js 3D/2D HTML viewer generator
+│   ├── backends/
+│   │   ├── base.py          # Abstract CADBackend
+│   │   ├── build123d_backend.py
+│   │   └── freecad_backend.py
+│   └── llm/
+│       ├── client.py        # Pluggable LLM clients
+│       └── prompts.py       # CAD prompts & few-shot examples
+├── examples/
+│   └── basic_pipeline_demo.py
+├── tests/
+│   └── test_pipeline.py
+├── pyproject.toml
+├── requirements.txt
+└── README.md
+```
+
+---
+
+## Testing
+
+Run the test suite with `pytest`:
+
+```bash
+pytest tests/ -v
+```
+
+---
+
+## License
+
+MIT License.

cadcore_ai-0.1.0/cadcore/__init__.py

@@ -0,0 +1,3 @@
+"""CadCore: Standalone Agentic CAD Generation Pipeline."""
+
+__version__ = "0.1.0"

cadcore_ai-0.1.0/cadcore/__main__.py

@@ -0,0 +1,6 @@
+"""Main entry point when invoked as python -m cadcore."""
+
+from cadcore.cli import main
+
+if __name__ == "__main__":
+    main()

cadcore_ai-0.1.0/cadcore/backends/__init__.py

@@ -0,0 +1,7 @@
+"""CAD Backends for CadCore."""
+
+from .base import CADBackend
+from .build123d_backend import Build123dBackend
+from .freecad_backend import FreeCADBackend
+
+__all__ = ["CADBackend", "Build123dBackend", "FreeCADBackend"]

cadcore_ai-0.1.0/cadcore/backends/base.py

@@ -0,0 +1,35 @@
+"""Base class for CAD engine backends."""
+
+import abc
+from pathlib import Path
+from typing import List, Tuple
+
+from cadcore.config import PipelineConfig
+
+
+class CADBackend(abc.ABC):
+    """Abstract interface for CAD modeling backends."""
+
+    def __init__(self, config: PipelineConfig):
+        self.config = config
+
+    @property
+    @abc.abstractmethod
+    def name(self) -> str:
+        """Name of the backend engine."""
+        pass
+
+    @abc.abstractmethod
+    def validate_environment(self) -> Tuple[bool, str]:
+        """Check if the backend runtime/dependencies are available."""
+        pass
+
+    @abc.abstractmethod
+    def prepare_script(self, raw_code: str, output_dir: Path) -> str:
+        """Post-process or wrap generated code to guarantee standard output paths."""
+        pass
+
+    @abc.abstractmethod
+    def get_execution_command(self, script_path: Path) -> List[str]:
+        """Get the subprocess command line to run the generated script."""
+        pass

cadcore_ai-0.1.0/cadcore/backends/build123d_backend.py

@@ -0,0 +1,117 @@
+"""Build123d CAD backend implementation."""
+
+import os
+import re
+import sys
+from pathlib import Path
+from typing import List, Tuple
+
+from cadcore.backends.base import CADBackend
+from cadcore.config import PipelineConfig
+
+
+class Build123dBackend(CADBackend):
+    """Build123d parametric OpenCASCADE backend."""
+
+    @property
+    def name(self) -> str:
+        return "build123d"
+
+    def _get_python_path(self) -> str:
+        """Resolve python interpreter path."""
+        if self.config.python_executable:
+            return self.config.python_executable
+        
+        # Check local .venv
+        venv_py = Path.cwd() / ".venv" / "Scripts" / "python.exe"
+        if venv_py.exists():
+            return str(venv_py)
+        
+        venv_py_posix = Path.cwd() / ".venv" / "bin" / "python"
+        if venv_py_posix.exists():
+            return str(venv_py_posix)
+
+        return sys.executable
+
+    def validate_environment(self) -> Tuple[bool, str]:
+        """Verify build123d is installed in the target Python interpreter."""
+        import subprocess
+        python_exe = self._get_python_path()
+        try:
+            res = subprocess.run(
+                [python_exe, "-c", "import build123d; print(build123d.__version__)"],
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            if res.returncode == 0:
+                return True, f"build123d v{res.stdout.strip()} ready at {python_exe}"
+            return False, f"Failed to import build123d: {res.stderr.strip()}"
+        except Exception as e:
+            return False, f"Python execution error: {e}"
+
+    def prepare_script(self, raw_code: str, output_dir: Path) -> str:
+        """Inject output directory and automatic fallback exporters if missing."""
+        out_str = str(output_dir.resolve()).replace("\\", "/")
+
+        # Sanitize any duplicate output_dir = Path(...) definitions from LLM script
+        cleaned_code = re.sub(r'output_dir\s*=\s*Path\([\'"][^\'"]*[\'"]\)', '# output_dir configured by CadCore', raw_code)
+
+        # Check if export statements are already present in code
+        has_step_export = "export_step" in cleaned_code
+        has_stl_export = "export_stl" in cleaned_code
+        has_svg_export = "ExportSVG" in cleaned_code
+
+        header = f"""# CadCore Auto-generated Script
+import sys
+from pathlib import Path
+output_dir = Path(r"{out_str}")
+output_dir.mkdir(parents=True, exist_ok=True)
+"""
+
+        # Wrap with safety fallback exporters
+        footer = f"""
+# CadCore Automatic Export Fallback
+try:
+    if 'result_part' in locals() and result_part is not None:
+        target_solid = result_part
+    elif 'part' in locals() and hasattr(part, 'part'):
+        target_solid = part.part
+    elif 'bracket' in locals() and hasattr(bracket, 'part'):
+        target_solid = bracket.part
+    elif 'flange' in locals() and hasattr(flange, 'part'):
+        target_solid = flange.part
+    else:
+        # Search for any Compound/Solid in locals
+        from build123d import Compound, Solid, Part
+        candidates = [v for v in locals().values() if isinstance(v, (Compound, Solid, Part))]
+        target_solid = candidates[-1] if candidates else None
+
+    if target_solid is not None:
+        step_path = output_dir / "model.step"
+        stl_path = output_dir / "model.stl"
+        svg_path = output_dir / "drawing.svg"
+
+        if not step_path.exists() or {not has_step_export}:
+            export_step(target_solid, str(step_path))
+        if not stl_path.exists() or {not has_stl_export}:
+            export_stl(target_solid, str(stl_path))
+        if not svg_path.exists() or {not has_svg_export}:
+            try:
+                visible, hidden = target_solid.project_to_viewport((1, 1, 1))
+                exporter = ExportSVG(scale=2.0)
+                exporter.add_layer("Visible", fill_color=Color("white"), line_color=Color("black"), line_weight=0.35)
+                exporter.add_shape(visible, layer="Visible")
+                exporter.write(str(svg_path))
+            except Exception as svg_err:
+                print(f"[Warning] SVG export failed: {{svg_err}}")
+        print(f"[CadCore] Successfully exported CAD artifacts to {{output_dir}}")
+    else:
+        raise RuntimeError("No valid 3D Solid or Compound was created in the script namespace. Ensure you build a solid (e.g. using BuildPart) and assign result_part = ...")
+except Exception as export_err:
+    raise export_err
+"""
+        return f"{header}\n{cleaned_code}\n{footer}"
+
+    def get_execution_command(self, script_path: Path) -> List[str]:
+        return [self._get_python_path(), str(script_path.resolve())]