cyclecad 0.1.10 → 0.2.1

package/app/agent-demo.html

@@ -876,10 +876,17 @@
 
             const commands = [
                 'create cylinder', 'create box', 'create sphere', 'create cone', 'create torus',
-                'add hole', 'add fillet', 'add chamfer', 'add pattern',
-                'sweep', 'loft', 'measure', 'section', 'undo', 'redo',
-                'copy', 'move', 'constraint', 'export stl', 'export step',
-                'help', 'history', 'clear', 'reset view', 'wireframe', 'grid'
+                'create plate', 'create gear', 'create bracket', 'create washer', 'create hexbolt', 'create flange',
+                'draw circle', 'make a cylinder', 'build box',
+                'add hole', 'drill hole', 'add fillet', 'round edges', 'add chamfer', 'bevel',
+                'shell', 'hollow out', 'mirror', 'pattern', 'add thread',
+                'extrude', 'revolve', 'sweep', 'loft', 'boolean cut', 'boolean union',
+                'material steel', 'material brass', 'material aluminum', 'color red', 'color chrome',
+                'move', 'rotate', 'scale', 'copy', 'delete',
+                'measure', 'section', 'wireframe', 'grid', 'shadows',
+                'sketch line', 'sketch rect', 'constraint parallel',
+                'export stl', 'export step', 'export gltf',
+                'undo', 'redo', 'reset view', 'help', 'history', 'clear'
             ];
 
             const matches = commands.filter(cmd => cmd.includes(value.toLowerCase()));
@@ -919,158 +926,489 @@
             document.getElementById('status-latency').textContent = latency + 'ms';
         }
 
+        // ─── NATURAL LANGUAGE PARSER ───
+        // Maps synonyms/phrases to canonical intents
+        const NLP_SHAPES = {
+          cylinder: ['cylinder', 'cylnder', 'cylindar', 'cyl', 'tube', 'pipe', 'rod', 'shaft', 'barrel', 'piston'],
+          box: ['box', 'cube', 'block', 'brick', 'rectangular', 'rect', 'cuboid', 'prism'],
+          sphere: ['sphere', 'ball', 'globe', 'orb'],
+          cone: ['cone', 'funnel', 'tapered'],
+          torus: ['torus', 'donut', 'doughnut', 'ring', 'o-ring'],
+          circle: ['circle', 'disc', 'disk', 'round', 'circular'],
+          plate: ['plate', 'slab', 'flat', 'panel', 'sheet'],
+          washer: ['washer', 'spacer', 'shim'],
+          hexbolt: ['hexbolt', 'hex bolt', 'bolt', 'hex head'],
+          gear: ['gear', 'cog', 'sprocket'],
+          flange: ['flange', 'collar', 'rim'],
+          bracket: ['bracket', 'l-bracket', 'angle'],
+        };
+
+        const NLP_ACTIONS = {
+          create:   ['create', 'make', 'build', 'draw', 'add a', 'add an', 'generate', 'design', 'model', 'sketch', 'construct', 'new'],
+          hole:     ['hole', 'bore', 'drill', 'pierce', 'through hole', 'counterbore', 'countersink'],
+          fillet:   ['fillet', 'round', 'round off', 'smooth', 'radius edge', 'blend'],
+          chamfer:  ['chamfer', 'bevel', 'chamfr', 'edge break', 'cut edge', 'angled edge'],
+          shell:    ['shell', 'hollow', 'thin wall', 'hollow out', 'scoop', 'empty'],
+          mirror:   ['mirror', 'reflect', 'flip', 'symmetry'],
+          pattern:  ['pattern', 'array', 'repeat', 'duplicate', 'copy array', 'replicate', 'linear pattern', 'circular pattern'],
+          extrude:  ['extrude', 'pull', 'push', 'extend', 'raise', 'boss'],
+          revolve:  ['revolve', 'rotate shape', 'spin', 'lathe', 'turn'],
+          sweep:    ['sweep', 'sweep along', 'follow path', 'rail'],
+          loft:     ['loft', 'blend between', 'transition', 'morph'],
+          thread:   ['thread', 'screw thread', 'threading', 'helix', 'helical'],
+          boolean:  ['boolean', 'cut', 'subtract', 'union', 'merge', 'intersect', 'combine', 'join'],
+          measure:  ['measure', 'distance', 'angle', 'how far', 'how big', 'dimension'],
+          section:  ['section', 'cross section', 'cut plane', 'slice', 'clip'],
+          move:     ['move', 'translate', 'shift', 'relocate', 'reposition', 'offset'],
+          rotate:   ['rotate', 'spin', 'turn', 'orient', 'tilt', 'angle'],
+          scale:    ['scale', 'resize', 'enlarge', 'shrink', 'bigger', 'smaller'],
+          copy:     ['copy', 'clone', 'duplicate'],
+          delete:   ['delete', 'remove', 'erase', 'clear part', 'destroy'],
+          material: ['material', 'color', 'colour', 'paint', 'steel', 'aluminum', 'aluminium', 'plastic', 'brass', 'titanium', 'copper', 'wood', 'glass'],
+          export:   ['export', 'save as', 'download', 'output'],
+          sketch:   ['sketch', '2d', 'draw line', 'draw rect', 'draw arc', 'draw spline', 'pencil'],
+          constraint: ['constraint', 'constrain', 'lock', 'fix', 'parallel', 'perpendicular', 'tangent', 'concentric', 'coincident', 'equal', 'horizontal', 'vertical'],
+          undo:     ['undo', 'go back', 'ctrl z', 'revert'],
+          redo:     ['redo', 'go forward', 'ctrl y'],
+          reset:    ['reset', 'home', 'reset view', 'default view', 'fit all', 'zoom fit'],
+          wireframe:['wireframe', 'wire', 'skeleton', 'mesh view'],
+          grid:     ['grid', 'show grid', 'toggle grid'],
+          shadows:  ['shadow', 'shadows', 'toggle shadows'],
+          help:     ['help', '?', 'commands', 'how to', 'what can'],
+          history:  ['history', 'log', 'past commands'],
+          clear:    ['clear', 'cls', 'clean'],
+        };
+
+        const MATERIAL_MAP = {
+          steel: { color: 0xb0b8c4, metalness: 0.8, roughness: 0.3, name: 'Steel' },
+          aluminum: { color: 0xd6dce4, metalness: 0.7, roughness: 0.25, name: 'Aluminum' },
+          aluminium: { color: 0xd6dce4, metalness: 0.7, roughness: 0.25, name: 'Aluminum' },
+          brass: { color: 0xc8a84e, metalness: 0.9, roughness: 0.2, name: 'Brass' },
+          copper: { color: 0xc87533, metalness: 0.85, roughness: 0.25, name: 'Copper' },
+          titanium: { color: 0x878c96, metalness: 0.75, roughness: 0.35, name: 'Titanium' },
+          plastic: { color: 0x2277cc, metalness: 0.0, roughness: 0.6, name: 'ABS Plastic' },
+          wood: { color: 0x9e7c4a, metalness: 0.0, roughness: 0.8, name: 'Wood' },
+          glass: { color: 0xaaddff, metalness: 0.1, roughness: 0.05, name: 'Glass' },
+          red: { color: 0xdd3333, metalness: 0.1, roughness: 0.5, name: 'Red' },
+          blue: { color: 0x3355dd, metalness: 0.1, roughness: 0.5, name: 'Blue' },
+          green: { color: 0x33aa33, metalness: 0.1, roughness: 0.5, name: 'Green' },
+          black: { color: 0x222222, metalness: 0.2, roughness: 0.4, name: 'Black' },
+          white: { color: 0xeeeeee, metalness: 0.1, roughness: 0.5, name: 'White' },
+          gold: { color: 0xffd700, metalness: 0.95, roughness: 0.15, name: 'Gold' },
+          chrome: { color: 0xcccccc, metalness: 1.0, roughness: 0.05, name: 'Chrome' },
+        };
+
+        function detectIntent(cmd) {
+          // Check each action category
+          for (const [action, keywords] of Object.entries(NLP_ACTIONS)) {
+            for (const kw of keywords) {
+              if (cmd.includes(kw)) return action;
+            }
+          }
+          // Check if it's a shape name on its own (e.g. "cylinder 50mm")
+          for (const [shape, aliases] of Object.entries(NLP_SHAPES)) {
+            for (const alias of aliases) {
+              if (cmd.includes(alias)) return 'create';
+            }
+          }
+          return null;
+        }
+
+        function detectShape(cmd) {
+          for (const [shape, aliases] of Object.entries(NLP_SHAPES)) {
+            for (const alias of aliases) {
+              if (cmd.includes(alias)) return shape;
+            }
+          }
+          return null;
+        }
+
+        function detectMaterial(cmd) {
+          for (const [mat, props] of Object.entries(MATERIAL_MAP)) {
+            if (cmd.includes(mat)) return { key: mat, ...props };
+          }
+          return null;
+        }
+
         function processCommand(command) {
             const cmd = command.toLowerCase().trim();
-
-            // Create commands
-            if (cmd.startsWith('create ')) {
-                const shape = cmd.substring(7).trim();
-                createShape(shape);
+            const intent = detectIntent(cmd);
+            const params = parseParamsNLP(cmd);
+
+            switch (intent) {
+              case 'create': {
+                const shape = detectShape(cmd);
+                if (shape) {
+                  createShape(shape + ' ' + cmd);
+                  saveHistory();
+                } else {
+                  logTerminal('What shape? Try: cylinder, box, sphere, cone, torus, plate, gear, bracket...', 'error');
+                }
+                break;
+              }
+              case 'hole': {
+                const r = params.radius || params.diameter / 2 || params.size || 5;
+                addHole(r);
                 saveHistory();
-            }
-            // Feature commands
-            else if (cmd.startsWith('add hole')) {
-                addHole(parseFloat(cmd.match(/radius\s+([\d.]+)/)?.[1] || 5));
+                break;
+              }
+              case 'fillet': {
+                const r = params.radius || params.size || 5;
+                addFillet(r);
                 saveHistory();
-            }
-            else if (cmd.startsWith('add fillet')) {
-                addFillet(parseFloat(cmd.match(/radius\s+([\d.]+)/)?.[1] || 5));
+                break;
+              }
+              case 'chamfer': {
+                const s = params.size || params.radius || 2;
+                addChamfer(s);
                 saveHistory();
-            }
-            else if (cmd.startsWith('add chamfer')) {
-                addChamfer(parseFloat(cmd.match(/size\s+([\d.]+)/)?.[1] || 2));
+                break;
+              }
+              case 'shell': {
+                const t = params.thickness || params.size || 2;
+                addShell(t);
                 saveHistory();
-            }
-            else if (cmd.startsWith('add pattern')) {
-                addPattern();
+                break;
+              }
+              case 'mirror': {
+                const plane = cmd.includes('x') ? 'X' : cmd.includes('z') ? 'Z' : 'Y';
+                addMirror(plane);
                 saveHistory();
-            }
-            else if (cmd.startsWith('sweep')) {
-                logTerminal('Sweep operation: select profile and path', 'success');
-                sceneState.features.push('Sweep');
-                updateFeatureTree();
-                runDesignReview();
+                break;
+              }
+              case 'pattern': {
+                const nx = params.x || params.count || 3;
+                const ny = params.y || 3;
+                const spacing = params.spacing || 60;
+                addPattern(nx, ny, spacing);
                 saveHistory();
-            }
-            else if (cmd.startsWith('loft')) {
-                logTerminal('Loft operation: select two profiles', 'success');
-                sceneState.features.push('Loft');
-                updateFeatureTree();
-                runManufacturingCheck();
+                break;
+              }
+              case 'extrude': {
+                const depth = params.depth || params.height || params.distance || 50;
+                addExtrude(depth);
                 saveHistory();
-            }
-            else if (cmd.startsWith('measure')) {
-                logTerminal('Measurement tool: click on two points to measure distance', 'success');
-            }
-            else if (cmd.startsWith('section')) {
-                logTerminal('Cross-section view: use arrow keys to adjust plane', 'success');
-            }
-            else if (cmd.startsWith('copy')) {
-                if (currentMesh) {
-                    logTerminal('Part copied to clipboard', 'success');
-                } else {
-                    logTerminal('No active part to copy', 'error');
-                }
-            }
-            else if (cmd.startsWith('move')) {
-                if (currentMesh) {
-                    logTerminal('Move tool active: drag part in viewport', 'success');
-                } else {
-                    logTerminal('No active part to move', 'error');
-                }
-            }
-            else if (cmd.startsWith('constraint')) {
-                if (currentMesh) {
-                    logTerminal('Constraint tool: add dimensional/geometric constraints', 'success');
+                break;
+              }
+              case 'revolve': {
+                const angle = params.angle || 360;
+                addRevolve(angle);
+                saveHistory();
+                break;
+              }
+              case 'sweep': {
+                addSweep();
+                saveHistory();
+                break;
+              }
+              case 'loft': {
+                addLoft();
+                saveHistory();
+                break;
+              }
+              case 'thread': {
+                const pitch = params.pitch || 1.5;
+                addThread(pitch);
+                saveHistory();
+                break;
+              }
+              case 'boolean': {
+                const op = cmd.includes('subtract') || cmd.includes('cut') ? 'subtract'
+                         : cmd.includes('intersect') ? 'intersect' : 'union';
+                addBoolean(op);
+                saveHistory();
+                break;
+              }
+              case 'material': {
+                const mat = detectMaterial(cmd);
+                if (mat) {
+                  setMaterial(mat);
                 } else {
-                    logTerminal('No active part for constraints', 'error');
+                  logTerminal('Materials: steel, aluminum, brass, copper, titanium, plastic, wood, glass, chrome, gold, red, blue, green, black, white', 'output');
                 }
-            }
-            else if (cmd === 'undo') {
-                undoOperation();
-            }
-            else if (cmd === 'redo') {
-                redoOperation();
-            }
-            else if (cmd === 'help') {
-                showHelp();
-            }
-            else if (cmd === 'history') {
-                showHistory();
-            }
-            else if (cmd.startsWith('export')) {
-                const format = cmd.includes('step') ? 'STEP' : 'STL';
-                if (currentMesh) {
-                    logTerminal(`Exporting as ${format}...`, 'success');
-                    logTerminal(`✓ File saved: part.${format.toLowerCase()}`, 'success');
+                break;
+              }
+              case 'move': {
+                const dx = params.x || 0, dy = params.y || 0, dz = params.z || 0;
+                movePart(dx, dy, dz);
+                break;
+              }
+              case 'rotate': {
+                const angle = params.angle || params.degrees || 90;
+                const axis = cmd.includes('x') ? 'x' : cmd.includes('z') ? 'z' : 'y';
+                rotatePart(axis, angle);
+                break;
+              }
+              case 'scale': {
+                const factor = params.factor || params.scale || (cmd.includes('bigger') || cmd.includes('enlarge') ? 1.5 : 0.7);
+                scalePart(factor);
+                break;
+              }
+              case 'copy': {
+                copyPart();
+                break;
+              }
+              case 'delete': {
+                deletePart();
+                saveHistory();
+                break;
+              }
+              case 'measure': {
+                doMeasure();
+                break;
+              }
+              case 'section': {
+                const axis = cmd.includes('x') ? 'X' : cmd.includes('z') ? 'Z' : 'Y';
+                doSection(axis);
+                break;
+              }
+              case 'sketch': {
+                doSketch(cmd);
+                break;
+              }
+              case 'constraint': {
+                doConstraint(cmd);
+                break;
+              }
+              case 'export': {
+                const format = cmd.includes('step') ? 'STEP' : cmd.includes('obj') ? 'OBJ' : cmd.includes('gltf') || cmd.includes('glb') ? 'GLTF' : 'STL';
+                doExport(format);
+                break;
+              }
+              case 'undo':      undoOperation(); break;
+              case 'redo':      redoOperation(); break;
+              case 'reset':     resetView(); break;
+              case 'wireframe': toggleWireframe(); break;
+              case 'grid':      toggleGrid(); break;
+              case 'shadows':   toggleShadows(); break;
+              case 'help':      showHelp(); break;
+              case 'history':   showHistory(); break;
+              case 'clear':     document.getElementById('terminal-output').innerHTML = ''; break;
+              default:
+                // Try fuzzy shape match as last resort
+                const lastShape = detectShape(cmd);
+                if (lastShape) {
+                  createShape(lastShape + ' ' + cmd);
+                  saveHistory();
                 } else {
-                    logTerminal('No active part to export', 'error');
+                  logTerminal(`Unknown command: "${command}". Type "help" for commands.`, 'error');
+                  logTerminal('Tip: Try natural language like "make a cylinder 50mm diameter 80 tall"', 'output');
                 }
             }
-            else if (cmd === 'clear') {
-                document.getElementById('terminal-output').innerHTML = '';
+        }
+
+        function parseParamsNLP(text) {
+            const params = {};
+            // "50mm diameter" or "diameter 50" or "diameter=50" or "d=50" or "50 mm dia"
+            const patterns = [
+              [/(?:diameter|diam|dia|dieameter|dieamieter|diamter|dimater|d)\s*[=:]\s*([\d.]+)/i, 'diameter'],
+              [/([\d.]+)\s*(?:mm\s*)?(?:diameter|diam|dia|dieameter|dieamieter|diamter|dimater)\b/i, 'diameter'],
+              [/(?:height|tall|h|long)\s*[=:]\s*([\d.]+)/i, 'height'],
+              [/([\d.]+)\s*(?:mm\s*)?(?:tall|high|height)\b/i, 'height'],
+              [/(?:radius|rad|r)\s*[=:]\s*([\d.]+)/i, 'radius'],
+              [/([\d.]+)\s*(?:mm\s*)?(?:radius|rad)\b/i, 'radius'],
+              [/(?:width|w)\s*[=:]\s*([\d.]+)/i, 'width'],
+              [/([\d.]+)\s*(?:mm\s*)?(?:wide|width)\b/i, 'width'],
+              [/(?:depth|deep|d)\s*[=:]\s*([\d.]+)/i, 'depth'],
+              [/([\d.]+)\s*(?:mm\s*)?(?:deep|depth)\b/i, 'depth'],
+              [/(?:thickness|thick|wall)\s*[=:]\s*([\d.]+)/i, 'thickness'],
+              [/([\d.]+)\s*(?:mm\s*)?(?:thick|thickness|wall)\b/i, 'thickness'],
+              [/(?:size|s)\s*[=:]\s*([\d.]+)/i, 'size'],
+              [/(?:tube)\s*[=:]\s*([\d.]+)/i, 'tube'],
+              [/(?:pitch)\s*[=:]\s*([\d.]+)/i, 'pitch'],
+              [/(?:angle|deg|degrees)\s*[=:]\s*([\d.]+)/i, 'angle'],
+              [/([\d.]+)\s*(?:degrees|deg)\b/i, 'angle'],
+              [/(?:count|n|num)\s*[=:]\s*([\d]+)/i, 'count'],
+              [/(?:spacing|gap)\s*[=:]\s*([\d.]+)/i, 'spacing'],
+              [/(?:factor|scale)\s*[=:]\s*([\d.]+)/i, 'factor'],
+              [/(?:distance|dist)\s*[=:]\s*([\d.]+)/i, 'distance'],
+              [/x\s*[=:]\s*([\d.-]+)/i, 'x'],
+              [/y\s*[=:]\s*([\d.-]+)/i, 'y'],
+              [/z\s*[=:]\s*([\d.-]+)/i, 'z'],
+            ];
+            // Also match "NxN" pattern → width x height (e.g. "100x50x30")
+            const dimMatch = text.match(/([\d.]+)\s*[x×]\s*([\d.]+)(?:\s*[x×]\s*([\d.]+))?/i);
+            if (dimMatch) {
+              params.width = parseFloat(dimMatch[1]);
+              params.height = parseFloat(dimMatch[2]);
+              if (dimMatch[3]) params.depth = parseFloat(dimMatch[3]);
             }
-            else if (cmd.startsWith('reset')) {
-                resetView();
+            for (const [regex, key] of patterns) {
+              const match = text.match(regex);
+              if (match && !params[key]) {
+                params[key] = parseFloat(match[1]);
+              }
             }
-            else {
-                logTerminal('Unknown command. Type "help" for assistance.', 'error');
+            // Bare number fallback: "circle 50" → diameter=50 or "hole 10" → radius=10
+            if (Object.keys(params).length === 0) {
+              const bareNum = text.match(/([\d.]+)/);
+              if (bareNum) params._bare = parseFloat(bareNum[1]);
             }
+            return params;
         }
 
-        function createShape(shape) {
+        function createShape(input) {
+            const shape = detectShape(input.toLowerCase());
+            const params = parseParamsNLP(input.toLowerCase());
+
             // Remove previous mesh
             if (currentMesh) scene.remove(currentMesh);
 
             let geometry;
-            const params = parseParams(shape);
-
-            if (shape.includes('cylinder')) {
-                const radius = params.diameter / 2 || 25;
-                const height = params.height || 80;
-                geometry = new THREE.CylinderGeometry(radius, radius, height, 32);
-                sceneState.currentPart = 'Cylinder';
-            } else if (shape.includes('box') || shape.includes('cube')) {
-                const w = params.width || 100;
-                const h = params.height || 100;
-                const d = params.depth || 100;
+            let partName;
+
+            switch (shape) {
+              case 'cylinder': {
+                const r = params.radius || (params.diameter ? params.diameter / 2 : (params._bare ? params._bare / 2 : 25));
+                const h = params.height || 80;
+                geometry = new THREE.CylinderGeometry(r, r, h, 32);
+                partName = `Cylinder (${r*2}×${h})`;
+                break;
+              }
+              case 'box': {
+                const w = params.width || params._bare || 100;
+                const h = params.height || (params.depth ? w : 100);
+                const d = params.depth || w;
                 geometry = new THREE.BoxGeometry(w, h, d);
-                sceneState.currentPart = 'Box';
-            } else if (shape.includes('sphere')) {
-                const radius = params.radius || 50;
-                geometry = new THREE.SphereGeometry(radius, 32, 32);
-                sceneState.currentPart = 'Sphere';
-            } else if (shape.includes('cone')) {
-                const radius = params.radius || 50;
-                const height = params.height || 100;
-                geometry = new THREE.ConeGeometry(radius, height, 32);
-                sceneState.currentPart = 'Cone';
-            } else if (shape.includes('torus')) {
-                const radius = params.radius || 50;
-                const tube = params.tube || 20;
-                geometry = new THREE.TorusGeometry(radius, tube, 16, 100);
-                sceneState.currentPart = 'Torus';
-            } else {
-                logTerminal('Unknown shape type. Try: cylinder, box, sphere, cone, torus', 'error');
+                partName = `Box (${w}×${h}×${d})`;
+                break;
+              }
+              case 'sphere': {
+                const r = params.radius || (params.diameter ? params.diameter / 2 : (params._bare ? params._bare / 2 : 50));
+                geometry = new THREE.SphereGeometry(r, 32, 32);
+                partName = `Sphere (r=${r})`;
+                break;
+              }
+              case 'cone': {
+                const r = params.radius || (params.diameter ? params.diameter / 2 : (params._bare ? params._bare / 2 : 50));
+                const h = params.height || 100;
+                geometry = new THREE.ConeGeometry(r, h, 32);
+                partName = `Cone (r=${r}, h=${h})`;
+                break;
+              }
+              case 'torus': {
+                const r = params.radius || (params._bare || 50);
+                const tube = params.tube || r * 0.4;
+                geometry = new THREE.TorusGeometry(r, tube, 16, 100);
+                partName = `Torus (R=${r}, t=${tube})`;
+                break;
+              }
+              case 'circle':
+              case 'plate': {
+                const r = params.radius || (params.diameter ? params.diameter / 2 : (params._bare ? params._bare / 2 : 50));
+                const h = params.height || params.thickness || 5;
+                geometry = new THREE.CylinderGeometry(r, r, h, 64);
+                partName = `${shape === 'circle' ? 'Disk' : 'Plate'} (d=${r*2}, t=${h})`;
+                break;
+              }
+              case 'washer': {
+                const outer = params.radius || (params.diameter ? params.diameter / 2 : 20);
+                const inner = outer * 0.5;
+                const h = params.height || params.thickness || 3;
+                const outerShape = new THREE.Shape();
+                outerShape.absarc(0, 0, outer, 0, Math.PI * 2, false);
+                const holePath = new THREE.Path();
+                holePath.absarc(0, 0, inner, 0, Math.PI * 2, true);
+                outerShape.holes.push(holePath);
+                geometry = new THREE.ExtrudeGeometry(outerShape, { depth: h, bevelEnabled: false });
+                geometry.rotateX(-Math.PI / 2);
+                partName = `Washer (OD=${outer*2}, ID=${inner*2}, t=${h})`;
+                break;
+              }
+              case 'gear': {
+                const r = params.radius || (params._bare || 40);
+                const teeth = params.count || 12;
+                const gearShape = new THREE.Shape();
+                const toothDepth = r * 0.15;
+                for (let i = 0; i < teeth; i++) {
+                  const a0 = (i / teeth) * Math.PI * 2;
+                  const a1 = ((i + 0.3) / teeth) * Math.PI * 2;
+                  const a2 = ((i + 0.5) / teeth) * Math.PI * 2;
+                  const a3 = ((i + 0.7) / teeth) * Math.PI * 2;
+                  const ri = r - toothDepth, ro = r + toothDepth;
+                  if (i === 0) gearShape.moveTo(Math.cos(a0) * ri, Math.sin(a0) * ri);
+                  gearShape.lineTo(Math.cos(a1) * ro, Math.sin(a1) * ro);
+                  gearShape.lineTo(Math.cos(a2) * ro, Math.sin(a2) * ro);
+                  gearShape.lineTo(Math.cos(a3) * ri, Math.sin(a3) * ri);
+                }
+                gearShape.closePath();
+                const h = params.height || params.thickness || 10;
+                geometry = new THREE.ExtrudeGeometry(gearShape, { depth: h, bevelEnabled: false });
+                geometry.rotateX(-Math.PI / 2);
+                partName = `Gear (${teeth}T, r=${r}, h=${h})`;
+                break;
+              }
+              case 'hexbolt': {
+                const r = params.radius || (params._bare || 10);
+                const h = params.height || 30;
+                const headH = r * 0.6;
+                const hexShape = new THREE.Shape();
+                for (let i = 0; i < 6; i++) {
+                  const a = (i / 6) * Math.PI * 2 - Math.PI / 6;
+                  if (i === 0) hexShape.moveTo(Math.cos(a) * r * 1.8, Math.sin(a) * r * 1.8);
+                  else hexShape.lineTo(Math.cos(a) * r * 1.8, Math.sin(a) * r * 1.8);
+                }
+                hexShape.closePath();
+                const headGeo = new THREE.ExtrudeGeometry(hexShape, { depth: headH, bevelEnabled: false });
+                const shaftGeo = new THREE.CylinderGeometry(r, r, h, 16);
+                shaftGeo.translate(0, -h / 2 - headH / 2, 0);
+                headGeo.rotateX(-Math.PI / 2);
+                geometry = headGeo; // simplified — just head for now
+                partName = `Hex Bolt (M${Math.round(r*2)}, L=${h})`;
+                break;
+              }
+              case 'flange': {
+                const r = params.radius || (params._bare || 60);
+                const innerR = r * 0.4;
+                const t = params.thickness || params.height || 8;
+                const flangeShape = new THREE.Shape();
+                flangeShape.absarc(0, 0, r, 0, Math.PI * 2, false);
+                const hole = new THREE.Path();
+                hole.absarc(0, 0, innerR, 0, Math.PI * 2, true);
+                flangeShape.holes.push(hole);
+                geometry = new THREE.ExtrudeGeometry(flangeShape, { depth: t, bevelEnabled: false });
+                geometry.rotateX(-Math.PI / 2);
+                partName = `Flange (OD=${r*2}, ID=${innerR*2}, t=${t})`;
+                break;
+              }
+              case 'bracket': {
+                const w = params.width || 80;
+                const h = params.height || 80;
+                const t = params.thickness || 5;
+                const bracketShape = new THREE.Shape();
+                bracketShape.moveTo(0, 0);
+                bracketShape.lineTo(w, 0);
+                bracketShape.lineTo(w, t);
+                bracketShape.lineTo(t, t);
+                bracketShape.lineTo(t, h);
+                bracketShape.lineTo(0, h);
+                bracketShape.closePath();
+                geometry = new THREE.ExtrudeGeometry(bracketShape, { depth: t * 3, bevelEnabled: false });
+                geometry.translate(-w / 2, -h / 2, -t * 1.5);
+                partName = `L-Bracket (${w}×${h}, t=${t})`;
+                break;
+              }
+              default:
+                logTerminal('Unknown shape. Try: cylinder, box, sphere, cone, torus, plate, disk, gear, bracket, washer, hexbolt, flange', 'error');
                 return;
             }
 
-            const material = new THREE.MeshStandardMaterial({
+            const mat = new THREE.MeshStandardMaterial({
                 color: 0x4a9eff,
                 roughness: 0.7,
                 metalness: 0.3
             });
 
-            currentMesh = new THREE.Mesh(geometry, material);
+            currentMesh = new THREE.Mesh(geometry, mat);
             currentMesh.castShadow = true;
             currentMesh.receiveShadow = true;
             scene.add(currentMesh);
 
-            // Reset features
-            sceneState.features = ['Base'];
+            sceneState.currentPart = partName;
+            sceneState.features = ['Base: ' + partName];
             sceneState.dimensions = params;
 
-            logTerminal(`✓ Created ${sceneState.currentPart} ${JSON.stringify(params)}`, 'success');
+            logTerminal(`✓ Created ${partName}`, 'success');
 
             updateFeatureTree();
             updateStatus();
@@ -1078,27 +1416,6 @@
             runDesignReview();
         }
 
-        function parseParams(text) {
-            const params = {};
-            const patterns = {
-                diameter: /diameter\s+([\d.]+)/,
-                height: /(?:height|tall)\s+([\d.]+)/,
-                radius: /radius\s+([\d.]+)/,
-                width: /width\s+([\d.]+)/,
-                depth: /depth\s+([\d.]+)/,
-                mm: /\d+(?:mm|\.?\d+)?/
-            };
-
-            for (let [key, regex] of Object.entries(patterns)) {
-                const match = text.match(regex);
-                if (match && key !== 'mm') {
-                    params[key] = parseFloat(match[1] || match[2]);
-                }
-            }
-
-            return params;
-        }
-
         function addHole(radius = 5) {
             if (!currentMesh) {
                 logTerminal('No active part. Create something first.', 'error');
@@ -1145,17 +1462,220 @@
             updateStatus();
         }
 
-        function addPattern() {
-            if (!currentMesh) {
-                logTerminal('No active part. Create something first.', 'error');
-                return;
+        function addPattern(nx = 3, ny = 3, spacing = 60) {
+            if (!currentMesh) { logTerminal('No active part. Create something first.', 'error'); return; }
+            // Create visual copies
+            for (let ix = 0; ix < nx; ix++) {
+              for (let iy = 0; iy < ny; iy++) {
+                if (ix === 0 && iy === 0) continue;
+                const clone = currentMesh.clone();
+                clone.position.x += ix * spacing;
+                clone.position.z += iy * spacing;
+                scene.add(clone);
+              }
             }
-            sceneState.features.push('Pattern (3×3)');
-            logTerminal('✓ Added pattern (3×3 rectangular array)', 'success');
+            sceneState.features.push(`Pattern (${nx}×${ny}, sp=${spacing})`);
+            logTerminal(`✓ Pattern ${nx}×${ny} at ${spacing}mm spacing`, 'success');
             updateFeatureTree();
             updateStatus();
         }
 
+        function addShell(thickness = 2) {
+            if (!currentMesh) { logTerminal('No active part. Create something first.', 'error'); return; }
+            // Visual: make transparent to show "hollow"
+            currentMesh.material = currentMesh.material.clone();
+            currentMesh.material.transparent = true;
+            currentMesh.material.opacity = 0.4;
+            currentMesh.material.side = THREE.DoubleSide;
+            // Create inner wireframe to show wall
+            const edges = new THREE.EdgesGeometry(currentMesh.geometry);
+            const wire = new THREE.LineSegments(edges, new THREE.LineBasicMaterial({ color: 0x00ddff, linewidth: 1 }));
+            wire.scale.setScalar(1 - thickness / 50);
+            currentMesh.add(wire);
+            sceneState.features.push(`Shell (t=${thickness}mm)`);
+            logTerminal(`✓ Shelled with ${thickness}mm wall thickness`, 'success');
+            updateFeatureTree(); updateStatus(); runManufacturingCheck();
+        }
+
+        function addMirror(plane = 'Y') {
+            if (!currentMesh) { logTerminal('No active part. Create something first.', 'error'); return; }
+            const clone = currentMesh.clone();
+            if (plane === 'X') clone.scale.x *= -1;
+            else if (plane === 'Y') clone.scale.y *= -1;
+            else clone.scale.z *= -1;
+            clone.position[plane.toLowerCase()] *= -1;
+            scene.add(clone);
+            sceneState.features.push(`Mirror (${plane} plane)`);
+            logTerminal(`✓ Mirrored across ${plane} plane`, 'success');
+            updateFeatureTree(); updateStatus();
+        }
+
+        function addExtrude(depth = 50) {
+            if (!currentMesh) { logTerminal('No active part. Create something first.', 'error'); return; }
+            currentMesh.scale.y *= (1 + depth / 50);
+            sceneState.features.push(`Extrude (${depth}mm)`);
+            logTerminal(`✓ Extruded ${depth}mm`, 'success');
+            updateFeatureTree(); updateStatus(); runDesignReview();
+        }
+
+        function addRevolve(angle = 360) {
+            if (!currentMesh) { logTerminal('No active part. Create something first.', 'error'); return; }
+            sceneState.features.push(`Revolve (${angle}°)`);
+            logTerminal(`✓ Revolved ${angle}°`, 'success');
+            updateFeatureTree(); updateStatus(); runDesignReview();
+        }
+
+        function addSweep() {
+            if (!currentMesh) { logTerminal('No active part. Create something first.', 'error'); return; }
+            sceneState.features.push('Sweep');
+            logTerminal('✓ Sweep: profile swept along path', 'success');
+            updateFeatureTree(); updateStatus(); runDesignReview();
+        }
+
+        function addLoft() {
+            if (!currentMesh) { logTerminal('No active part. Create something first.', 'error'); return; }
+            sceneState.features.push('Loft');
+            logTerminal('✓ Loft: blended between profiles', 'success');
+            updateFeatureTree(); updateStatus(); runManufacturingCheck();
+        }
+
+        function addThread(pitch = 1.5) {
+            if (!currentMesh) { logTerminal('No active part. Create something first.', 'error'); return; }
+            // Visual: add helical line
+            const box = new THREE.Box3().setFromObject(currentMesh);
+            const h = box.getSize(new THREE.Vector3()).y;
+            const r = box.getSize(new THREE.Vector3()).x / 2 * 1.02;
+            const pts = [];
+            const turns = h / pitch;
+            for (let i = 0; i <= turns * 32; i++) {
+              const t = i / 32;
+              const angle = t * Math.PI * 2;
+              const y = (t * pitch) - h / 2;
+              pts.push(new THREE.Vector3(Math.cos(angle) * r, y, Math.sin(angle) * r));
+            }
+            const helixGeo = new THREE.BufferGeometry().setFromPoints(pts);
+            const helix = new THREE.Line(helixGeo, new THREE.LineBasicMaterial({ color: 0xff8800 }));
+            currentMesh.add(helix);
+            sceneState.features.push(`Thread (pitch=${pitch}mm)`);
+            logTerminal(`✓ Thread applied (pitch ${pitch}mm, ${Math.round(turns)} turns)`, 'success');
+            updateFeatureTree(); updateStatus();
+        }
+
+        function addBoolean(op = 'union') {
+            if (!currentMesh) { logTerminal('No active part. Create something first.', 'error'); return; }
+            sceneState.features.push(`Boolean ${op}`);
+            logTerminal(`✓ Boolean ${op} applied`, 'success');
+            updateFeatureTree(); updateStatus();
+        }
+
+        function setMaterial(mat) {
+            if (!currentMesh) { logTerminal('No active part. Create something first.', 'error'); return; }
+            currentMesh.material = currentMesh.material.clone();
+            currentMesh.material.color.setHex(mat.color);
+            currentMesh.material.metalness = mat.metalness;
+            currentMesh.material.roughness = mat.roughness;
+            currentMesh.material.needsUpdate = true;
+            sceneState.features.push(`Material: ${mat.name}`);
+            logTerminal(`✓ Material set to ${mat.name}`, 'success');
+            updateFeatureTree(); updateStatus();
+        }
+
+        function movePart(dx, dy, dz) {
+            if (!currentMesh) { logTerminal('No active part.', 'error'); return; }
+            currentMesh.position.x += dx;
+            currentMesh.position.y += dy;
+            currentMesh.position.z += dz;
+            logTerminal(`✓ Moved by (${dx}, ${dy}, ${dz})`, 'success');
+        }
+
+        function rotatePart(axis, angleDeg) {
+            if (!currentMesh) { logTerminal('No active part.', 'error'); return; }
+            const rad = angleDeg * Math.PI / 180;
+            if (axis === 'x') currentMesh.rotation.x += rad;
+            else if (axis === 'y') currentMesh.rotation.y += rad;
+            else currentMesh.rotation.z += rad;
+            logTerminal(`✓ Rotated ${angleDeg}° around ${axis.toUpperCase()}`, 'success');
+        }
+
+        function scalePart(factor) {
+            if (!currentMesh) { logTerminal('No active part.', 'error'); return; }
+            currentMesh.scale.multiplyScalar(factor);
+            logTerminal(`✓ Scaled by ${factor}x`, 'success');
+        }
+
+        function copyPart() {
+            if (!currentMesh) { logTerminal('No active part.', 'error'); return; }
+            const clone = currentMesh.clone();
+            clone.position.x += 50;
+            scene.add(clone);
+            logTerminal('✓ Part duplicated (offset +50mm X)', 'success');
+        }
+
+        function deletePart() {
+            if (!currentMesh) { logTerminal('No active part.', 'error'); return; }
+            scene.remove(currentMesh);
+            currentMesh = null;
+            sceneState.currentPart = null;
+            sceneState.features = [];
+            logTerminal('✓ Part deleted', 'success');
+            updateFeatureTree(); updateStatus();
+        }
+
+        function doMeasure() {
+            if (!currentMesh) { logTerminal('No active part to measure.', 'error'); return; }
+            const box = new THREE.Box3().setFromObject(currentMesh);
+            const size = box.getSize(new THREE.Vector3());
+            const volume = size.x * size.y * size.z;
+            logTerminal(`✓ Dimensions: ${size.x.toFixed(1)} × ${size.y.toFixed(1)} × ${size.z.toFixed(1)} mm`, 'success');
+            logTerminal(`  Bounding volume: ${(volume / 1000).toFixed(1)} cm³`, 'output');
+        }
+
+        function doSection(axis = 'Y') {
+            if (!currentMesh) { logTerminal('No active part.', 'error'); return; }
+            const plane = new THREE.Plane();
+            if (axis === 'X') plane.set(new THREE.Vector3(1, 0, 0), 0);
+            else if (axis === 'Y') plane.set(new THREE.Vector3(0, 1, 0), 0);
+            else plane.set(new THREE.Vector3(0, 0, 1), 0);
+            currentMesh.material = currentMesh.material.clone();
+            currentMesh.material.clippingPlanes = [plane];
+            currentMesh.material.side = THREE.DoubleSide;
+            renderer.localClippingEnabled = true;
+            sceneState.features.push(`Section (${axis} plane)`);
+            logTerminal(`✓ Section cut along ${axis} plane`, 'success');
+            updateFeatureTree(); updateStatus();
+        }
+
+        function doSketch(cmd) {
+            logTerminal('✓ 2D sketch mode active', 'success');
+            if (cmd.includes('line')) logTerminal('  Draw line: click start + end points', 'output');
+            else if (cmd.includes('rect')) logTerminal('  Draw rectangle: click corner + drag', 'output');
+            else if (cmd.includes('arc')) logTerminal('  Draw arc: click center, start, end', 'output');
+            else if (cmd.includes('spline')) logTerminal('  Draw spline: click control points, Enter to finish', 'output');
+            else logTerminal('  Commands: draw line, draw rect, draw arc, draw spline', 'output');
+            sceneState.features.push('Sketch');
+            updateFeatureTree();
+        }
+
+        function doConstraint(cmd) {
+            const types = ['parallel', 'perpendicular', 'tangent', 'concentric', 'coincident', 'equal', 'horizontal', 'vertical', 'fixed'];
+            const found = types.find(t => cmd.includes(t));
+            if (found) {
+              logTerminal(`✓ Constraint: ${found} applied`, 'success');
+              sceneState.features.push(`Constraint: ${found}`);
+            } else {
+              logTerminal('Constraints: parallel, perpendicular, tangent, concentric, coincident, equal, horizontal, vertical, fixed', 'output');
+            }
+            updateFeatureTree();
+        }
+
+        function doExport(format = 'STL') {
+            if (!currentMesh) { logTerminal('No active part to export.', 'error'); return; }
+            logTerminal(`✓ Exporting as ${format}...`, 'success');
+            logTerminal(`  File: ${(sceneState.currentPart || 'part').replace(/[^a-zA-Z0-9]/g, '_')}.${format.toLowerCase()}`, 'output');
+            logTerminal(`  Features: ${sceneState.features.length}`, 'output');
+            logTerminal(`✓ Export complete`, 'success');
+        }
+
         // History Management
         function saveHistory() {
             operationHistory.splice(historyPointer);
@@ -1343,32 +1863,44 @@
 
         function showHelp() {
             logTerminal('=== cycleCAD Agent Commands ===', 'output');
+            logTerminal('Use natural language! Examples:', 'output');
+            logTerminal('', 'output');
+            logTerminal('CREATE (12 shape types):', 'output');
+            logTerminal('  "make a cylinder 50mm diameter 80 tall"', 'output');
+            logTerminal('  "draw circle with 50mm diameter"', 'output');
+            logTerminal('  "build box 100x50x30"', 'output');
+            logTerminal('  "create gear radius=40 count=16"', 'output');
+            logTerminal('  "sphere, cone, torus, plate, washer, hexbolt, flange, bracket"', 'output');
             logTerminal('', 'output');
-            logTerminal('CREATE SHAPES:', 'output');
-            logTerminal('  create cylinder diameter=50 height=80', 'output');
-            logTerminal('  create box width=100 height=100 depth=100', 'output');
-            logTerminal('  create sphere radius=50', 'output');
-            logTerminal('  create cone radius=50 height=100', 'output');
-            logTerminal('  create torus radius=50 tube=20', 'output');
+            logTerminal('MODIFY:', 'output');
+            logTerminal('  "drill a hole radius 10" | "bore 8mm"', 'output');
+            logTerminal('  "fillet 5" | "round edges 3mm"', 'output');
+            logTerminal('  "chamfer 2" | "bevel edges"', 'output');
+            logTerminal('  "shell 2mm" | "hollow out"', 'output');
+            logTerminal('  "mirror across X" | "flip"', 'output');
+            logTerminal('  "pattern 4x3 spacing=60"', 'output');
+            logTerminal('  "add thread pitch=1.5"', 'output');
             logTerminal('', 'output');
-            logTerminal('MODIFY FEATURES:', 'output');
-            logTerminal('  add hole radius=10', 'output');
-            logTerminal('  add fillet radius=5', 'output');
-            logTerminal('  add chamfer size=2', 'output');
-            logTerminal('  add pattern', 'output');
+            logTerminal('OPERATIONS:', 'output');
+            logTerminal('  "extrude 50" | "revolve 360" | "sweep" | "loft"', 'output');
+            logTerminal('  "boolean cut" | "union" | "intersect"', 'output');
+            logTerminal('  "move x=10 y=20" | "rotate 45 degrees"', 'output');
+            logTerminal('  "scale 1.5" | "bigger" | "smaller"', 'output');
+            logTerminal('  "copy" | "delete" | "measure"', 'output');
             logTerminal('', 'output');
-            logTerminal('ADVANCED OPERATIONS:', 'output');
-            logTerminal('  sweep | loft | measure | section', 'output');
-            logTerminal('  copy | move | constraint', 'output');
+            logTerminal('APPEARANCE:', 'output');
+            logTerminal('  "material steel" | "paint it brass" | "color red"', 'output');
+            logTerminal('  "section X" | "wireframe" | "grid" | "shadows"', 'output');
             logTerminal('', 'output');
-            logTerminal('VIEWPORT CONTROL:', 'output');
-            logTerminal('  reset view | wireframe | grid | shadows', 'output');
+            logTerminal('SKETCH & CONSTRAINTS:', 'output');
+            logTerminal('  "sketch line" | "draw rect" | "draw arc"', 'output');
+            logTerminal('  "constraint parallel" | "perpendicular" | "tangent"', 'output');
             logTerminal('', 'output');
-            logTerminal('HISTORY & EXPORT:', 'output');
-            logTerminal('  undo | redo | history', 'output');
-            logTerminal('  export stl | export step', 'output');
+            logTerminal('EXPORT:', 'output');
+            logTerminal('  "export stl" | "export step" | "export gltf"', 'output');
             logTerminal('', 'output');
-            logTerminal('KEYBOARD: ↑/↓ = history, Ctrl+Z/Y = undo/redo, ? = help', 'output');
+            logTerminal('OTHER: undo, redo, reset, history, clear, help', 'output');
+            logTerminal('KEYBOARD: ↑/↓ = history, Tab = autocomplete, Ctrl+Z/Y, ?', 'output');
         }
 
         function showHistory() {
@@ -1384,13 +1916,25 @@
 
         function showExamples() {
             const examples = [
-                'create cylinder diameter=50 height=80',
-                'add hole radius 10',
-                'add fillet radius 5',
-                'add chamfer size 2',
-                'add pattern',
-                'sweep',
-                'loft',
+                'make a cylinder 50mm diameter 80 tall',
+                'draw circle with 100mm diameter',
+                'build box 100x50x30',
+                'create gear radius=40 count=16',
+                'create sphere radius 25',
+                'drill a hole radius 10',
+                'fillet 5mm',
+                'chamfer 2',
+                'shell 2mm thick',
+                'mirror across X',
+                'pattern 3x3 spacing=50',
+                'add thread pitch=1.5',
+                'extrude 50',
+                'material steel',
+                'color brass',
+                'rotate 45 degrees',
+                'scale 1.5',
+                'section Y',
+                'measure',
                 'export stl',
                 'help'
             ];
@@ -1455,8 +1999,9 @@
             initThreeJS();
             initVoiceRecognition();
             document.getElementById('command-input').focus();
-            logTerminal('✓ Agent Demo Ready', 'success');
-            logTerminal('Try: "create cylinder diameter=50 height=80"', 'output');
+            logTerminal('✓ Agent Demo Ready — 12 shapes, 20+ operations', 'success');
+            logTerminal('Try natural language: "make a cylinder 50mm diameter 80 tall"', 'output');
+            logTerminal('Or: "draw circle with 50mm diameter" | "build box 100x50x30"', 'output');
         });
     </script>
 </body>