@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/openscad-mcp-server/legacy/rtfmd/knowledge/ai/natural-language-processing.md

@@ -0,0 +1,78 @@
+# Natural Language Processing for 3D Modeling
+
+<metadata>
+  author: devin-ai-integration
+  timestamp: 2025-03-21T01:30:00Z
+  version: 1.0.0
+  tags: [nlp, 3d-modeling, parameter-extraction, pattern-matching]
+</metadata>
+
+## Overview
+
+Natural Language Processing (NLP) techniques can be applied to extract 3D modeling parameters and intentions from user descriptions. This knowledge document outlines approaches for translating natural language into structured data for 3D model generation.
+
+## Approaches
+
+### Pattern Matching
+
+Regular expression pattern matching is effective for identifying:
+
+- Dimensions and measurements
+- Shape types and primitives
+- Operations (union, difference, etc.)
+- Transformations (rotate, scale, etc.)
+- Material properties and colors
+
+Example patterns:
+```python
+# Dimension pattern
+dimension_pattern = r'(\d+(?:\.\d+)?)\s*(mm|cm|m|inch|in)'
+
+# Shape pattern
+shape_pattern = r'\b(cube|box|sphere|ball|cylinder|tube|cone|pyramid)\b'
+```
+
+### Contextual Understanding
+
+Beyond simple pattern matching, contextual understanding involves:
+
+- Identifying relationships between objects
+- Understanding relative positioning
+- Resolving ambiguous references
+- Maintaining dialog state for multi-turn interactions
+
+### Hybrid Approaches
+
+Combining pattern matching with contextual rules provides:
+
+- Better accuracy than pure pattern matching
+- Lower computational requirements than full ML approaches
+- More maintainable and debuggable systems
+- Flexibility to handle diverse descriptions
+
+## Parameter Extraction
+
+Key parameters to extract include:
+
+- **Dimensions**: Width, height, depth, radius, diameter
+- **Positions**: Coordinates, relative positions
+- **Operations**: Boolean operations, transformations
+- **Features**: Holes, fillets, chamfers, text
+- **Properties**: Color, material, finish
+
+## Implementation Considerations
+
+- **Ambiguity Resolution**: Handle cases where measurements could apply to multiple dimensions
+- **Default Values**: Provide sensible defaults for unspecified parameters
+- **Unit Conversion**: Convert between different measurement units
+- **Error Handling**: Gracefully handle unparseable or contradictory descriptions
+- **Dialog Management**: Maintain state for multi-turn interactions to refine models
+
+## Evaluation Metrics
+
+Effective NLP for 3D modeling can be evaluated by:
+
+- **Accuracy**: Correctness of extracted parameters
+- **Completeness**: Percentage of required parameters successfully extracted
+- **Robustness**: Ability to handle diverse phrasings and descriptions
+- **User Satisfaction**: Subjective evaluation of the resulting models

package/mcp_servers/openscad-mcp-server/legacy/rtfmd/knowledge/nlp/parameter-extraction.md

@@ -0,0 +1,173 @@
+# Parameter Extraction for 3D Modeling
+
+<metadata>
+  author: devin-ai-integration
+  timestamp: 2025-03-21T01:30:00Z
+  version: 1.0.0
+  tags: [parameter-extraction, nlp, 3d-modeling, regex]
+</metadata>
+
+## Overview
+
+Parameter extraction is the process of identifying and extracting structured data from natural language descriptions of 3D models. This is a critical component in translating user intentions into actionable modeling parameters.
+
+## Extraction Techniques
+
+### Regular Expression Patterns
+
+Regular expressions provide a powerful way to extract parameters:
+
+```python
+# Extract dimensions with units
+dimension_pattern = r'(\d+(?:\.\d+)?)\s*(mm|cm|m|inch|in)'
+
+# Extract color information
+color_pattern = r'\b(red|green|blue|yellow|black|white|purple|orange|brown)\b'
+
+# Extract shape type
+shape_pattern = r'\b(cube|box|sphere|ball|cylinder|tube|cone|pyramid)\b'
+```
+
+### Contextual Parameter Association
+
+After extracting raw values, they must be associated with the correct parameter:
+
+```python
+def associate_dimension(value, description):
+    """Associate a dimension value with the correct parameter based on context."""
+    if "width" in description or "wide" in description:
+        return ("width", value)
+    elif "height" in description or "tall" in description:
+        return ("height", value)
+    elif "depth" in description or "deep" in description:
+        return ("depth", value)
+    elif "radius" in description:
+        return ("radius", value)
+    elif "diameter" in description:
+        return ("radius", value / 2)  # Convert diameter to radius
+    else:
+        return ("unknown", value)
+```
+
+### Default Parameters
+
+Provide sensible defaults for unspecified parameters:
+
+```python
+default_parameters = {
+    "cube": {
+        "width": 10,
+        "height": 10,
+        "depth": 10,
+        "center": True
+    },
+    "sphere": {
+        "radius": 10,
+        "segments": 32
+    },
+    "cylinder": {
+        "radius": 5,
+        "height": 10,
+        "center": True,
+        "segments": 32
+    }
+}
+```
+
+## Parameter Types
+
+Common parameter types to extract include:
+
+- **Dimensions**: Width, height, depth, radius, diameter
+- **Positions**: X, Y, Z coordinates
+- **Angles**: Rotation angles
+- **Counts**: Number of sides, segments, iterations
+- **Booleans**: Center, solid/hollow
+- **Colors**: RGB values or named colors
+- **Operations**: Union, difference, intersection
+- **Transformations**: Translate, rotate, scale, mirror
+
+## Challenges and Solutions
+
+### Ambiguity
+
+When parameters are ambiguous, use contextual clues or ask clarifying questions:
+
+```python
+def resolve_ambiguity(value, possible_parameters, description):
+    """Resolve ambiguity between possible parameters."""
+    # Try to resolve using context
+    for param in possible_parameters:
+        if param in description:
+            return param
+    
+    # If still ambiguous, return a question to ask
+    return f"Is {value} the {' or '.join(possible_parameters)}?"
+```
+
+### Unit Conversion
+
+Convert all measurements to a standard unit (millimeters):
+
+```python
+def convert_to_mm(value, unit):
+    """Convert a value from the given unit to millimeters."""
+    if unit in ["mm", "millimeter", "millimeters"]:
+        return value
+    elif unit in ["cm", "centimeter", "centimeters"]:
+        return value * 10
+    elif unit in ["m", "meter", "meters"]:
+        return value * 1000
+    elif unit in ["in", "inch", "inches"]:
+        return value * 25.4
+    else:
+        return value  # Assume mm if unit is unknown
+```
+
+### Dialog State Management
+
+Maintain state across multiple interactions:
+
+```python
+class DialogState:
+    def __init__(self):
+        self.shape_type = None
+        self.parameters = {}
+        self.questions = []
+        self.confirmed = False
+    
+    def add_parameter(self, name, value):
+        self.parameters[name] = value
+    
+    def add_question(self, question):
+        self.questions.append(question)
+    
+    def is_complete(self):
+        """Check if all required parameters are present."""
+        if not self.shape_type:
+            return False
+        
+        required_params = self.get_required_parameters()
+        return all(param in self.parameters for param in required_params)
+    
+    def get_required_parameters(self):
+        """Get the required parameters for the current shape type."""
+        if self.shape_type == "cube":
+            return ["width", "height", "depth"]
+        elif self.shape_type == "sphere":
+            return ["radius"]
+        elif self.shape_type == "cylinder":
+            return ["radius", "height"]
+        else:
+            return []
+```
+
+## Best Practices
+
+- Start with simple pattern matching and add complexity as needed
+- Provide sensible defaults for all parameters
+- Use contextual clues to resolve ambiguity
+- Maintain dialog state for multi-turn interactions
+- Convert all measurements to a standard unit
+- Validate extracted parameters for reasonableness
+- Handle errors gracefully with helpful messages

package/mcp_servers/openscad-mcp-server/legacy/rtfmd/knowledge/openscad/export-formats.md

@@ -0,0 +1,91 @@
+# OpenSCAD Export Formats
+
+<metadata>
+  author: devin-ai-integration
+  timestamp: 2025-03-21T12:00:00Z
+  version: 1.0.0
+  tags: [openscad, export-formats, 3d-printing, prusa, bambu]
+</metadata>
+
+## Overview
+
+OpenSCAD supports exporting 3D models in various formats, each with different capabilities for preserving parametric properties and metadata. This document focuses on formats suitable for Prusa and Bambu printers, with an emphasis on alternatives to STL.
+
+## Recommended Formats
+
+### 3MF (3D Manufacturing Format)
+
+3MF is a modern replacement for STL that addresses many of its limitations:
+
+- **Metadata Support**: Includes model information, materials, colors
+- **Compact Size**: More efficient encoding than STL
+- **Multiple Objects**: Can contain multiple parts in a single file
+- **Printer Compatibility**: Widely supported by Prusa and Bambu printers
+- **Implementation**: ZIP archive containing XML files
+
+```openscad
+// Export to 3MF from command line
+// openscad -o model.3mf model.scad
+```
+
+### AMF (Additive Manufacturing File Format)
+
+AMF is another modern format that supports:
+
+- **Material Information**: Material properties and colors
+- **Curved Surfaces**: Better representation than STL's triangles
+- **Metadata**: Design information and parameters
+- **Implementation**: XML-based format
+
+```openscad
+// Export to AMF from command line
+// openscad -o model.amf model.scad
+```
+
+### CSG (Constructive Solid Geometry)
+
+CSG is OpenSCAD's native format:
+
+- **Fully Parametric**: Preserves all construction operations
+- **Editable**: Can be reopened and modified in OpenSCAD
+- **Implementation**: OpenSCAD's internal representation
+
+```openscad
+// Export to CSG from command line
+// openscad -o model.csg model.scad
+```
+
+### SCAD (OpenSCAD Source Code)
+
+The original SCAD file preserves all parametric properties:
+
+- **Complete Parameterization**: All variables and relationships
+- **Code Structure**: Modules, functions, and comments
+- **Implementation**: Text file with OpenSCAD code
+
+## Printer Compatibility
+
+### Prusa Printers
+
+Prusa printers work well with:
+
+- **3MF**: Full support in PrusaSlicer
+- **AMF**: Good support for materials and colors
+- **STL**: Supported but with limitations
+
+### Bambu Printers
+
+Bambu printers work best with:
+
+- **3MF**: Preferred format for Bambu Lab software
+- **AMF**: Well supported
+- **STL**: Basic support
+
+## Implementation Notes
+
+When implementing export functionality:
+
+1. Use OpenSCAD's command-line interface for reliable exports
+2. Add metadata to 3MF and AMF files for better organization
+3. Test exported files with actual printer software
+4. Validate files before sending to printers

package/mcp_servers/openscad-mcp-server/legacy/rtfmd/knowledge/openscad/openscad-basics.md

@@ -0,0 +1,66 @@
+# OpenSCAD Basics
+
+<metadata>
+  author: devin-ai-integration
+  timestamp: 2025-03-21T01:30:00Z
+  version: 1.0.0
+  tags: [openscad, 3d-modeling, csg, parametric-design]
+</metadata>
+
+## Overview
+
+OpenSCAD is a programmer's solid 3D CAD modeler that uses a scripting language to define 3D objects. Unlike traditional CAD software that focuses on interactive modeling, OpenSCAD emphasizes programmatic and parametric design.
+
+## Key Concepts
+
+### Constructive Solid Geometry (CSG)
+
+OpenSCAD uses CSG operations to create complex models by combining simpler primitives:
+
+- **Union**: Combines multiple objects (`union() { ... }`)
+- **Difference**: Subtracts one object from another (`difference() { ... }`)
+- **Intersection**: Creates an object from the overlapping portions of other objects (`intersection() { ... }`)
+
+### Primitive Shapes
+
+OpenSCAD provides several built-in primitive shapes:
+
+- **Cube**: `cube([width, depth, height], center=true/false)`
+- **Sphere**: `sphere(r=radius, $fn=segments)`
+- **Cylinder**: `cylinder(h=height, r=radius, center=true/false, $fn=segments)`
+- **Polyhedron**: For complex shapes with defined faces
+
+### Transformations
+
+Objects can be transformed using:
+
+- **Translate**: `translate([x, y, z]) { ... }`
+- **Rotate**: `rotate([x_deg, y_deg, z_deg]) { ... }`
+- **Scale**: `scale([x, y, z]) { ... }`
+- **Mirror**: `mirror([x, y, z]) { ... }`
+
+### Parametric Design
+
+OpenSCAD excels at parametric design:
+
+- Variables can define dimensions and relationships
+- Modules can create reusable components with parameters
+- Mathematical expressions can define complex relationships
+
+## Command Line Usage
+
+OpenSCAD can be run headless using command-line options:
+
+- Generate STL: `openscad -o output.stl input.scad`
+- Pass parameters: `openscad -D "width=10" -D "height=20" -o output.stl input.scad`
+- Generate PNG preview: `openscad --camera=0,0,0,0,0,0,50 --imgsize=800,600 -o preview.png input.scad`
+
+## Best Practices
+
+- Use modules for reusable components
+- Parameterize designs for flexibility
+- Use descriptive variable names
+- Comment code for clarity
+- Organize complex designs hierarchically
+- Use $fn judiciously for performance
+- Ensure models are manifold (watertight) for 3D printing

package/mcp_servers/openscad-mcp-server/legacy/rtfmd/knowledge/openscad/primitive-testing.md

@@ -0,0 +1,79 @@
+# Testing OpenSCAD Primitives
+
+<metadata>
+  author: devin-ai-integration
+  timestamp: 2025-03-21T12:00:00Z
+  version: 1.0.0
+  tags: [openscad, primitives, testing, 3d-modeling]
+</metadata>
+
+## Overview
+
+Testing OpenSCAD primitives is essential to ensure that the MCP server can reliably generate and export 3D models. This document outlines approaches for programmatically testing primitives and validating their exports.
+
+## Primitive Types
+
+The OpenSCAD MCP Server supports these primitive types:
+
+- **Basic Shapes**: cube, sphere, cylinder
+- **Complex Shapes**: cone, torus, hexagonal_prism
+- **Containers**: hollow_box, rounded_box, tube
+- **Text**: 3D text with customizable parameters
+
+## Testing Approach
+
+### Parameter Testing
+
+Each primitive should be tested with:
+
+- **Default Parameters**: Ensure the primitive renders correctly with default values
+- **Boundary Values**: Test minimum and maximum reasonable values
+- **Special Cases**: Test cases like zero dimensions, negative values
+
+### Export Testing
+
+For each primitive and parameter set:
+
+- **Export Formats**: Test export to 3MF, AMF, CSG, and SCAD formats
+- **Format Validation**: Ensure exported files meet format specifications
+- **Metadata Preservation**: Verify that parametric properties are preserved
+
+### Integration Testing
+
+Test the full pipeline:
+
+- **Natural Language → Parameters**: Test parameter extraction
+- **Parameters → OpenSCAD Code**: Test code generation
+- **OpenSCAD Code → Export**: Test file export
+- **Export → Printer**: Test compatibility with printer software
+
+## Validation Criteria
+
+Exported models should meet these criteria:
+
+- **Manifold**: Models should be watertight (no holes in the mesh)
+- **Valid Format**: Files should validate against format specifications
+- **Metadata**: Should contain relevant model metadata
+- **Render Performance**: Models should render efficiently
+
+## Implementation
+
+The `PrimitiveTester` class implements this testing approach:
+
+```python
+# Example usage
+tester = PrimitiveTester(code_generator, cad_exporter)
+results = tester.test_all_primitives()
+
+# Test specific primitives
+cube_results = tester.test_primitive("cube")
+```
+
+## Printer Compatibility Tests
+
+Before sending to physical printers:
+
+1. Import exports into PrusaSlicer or Bambu Studio
+2. Check for import warnings or errors
+3. Verify that models slice correctly
+4. Test prints with simple examples