cyclecad 0.8.7 → 0.9.6

package/app/js/ai-chat.js

@@ -1,9 +1,15 @@
 /**
- * ai-chat.js - Natural Language to CAD Command Parser
+ * ai-chat.js - Smart CAD Assistant with LLM + Local Fallback
  * cycleCAD: Browser-based parametric 3D modeler
  *
- * Parses natural language descriptions into structured CAD commands.
- * Supports primitives, mechanical parts, operations, and optional LLM enhancement.
+ * Features:
+ * - Conversational AI that understands follow-ups ("make it bigger", "remove it")
+ * - Scene-aware: knows what parts exist and their dimensions
+ * - Scene operations: delete, move, rotate, scale, hide, show, undo, redo
+ * - Boolean ops: intersect, subtract, union
+ * - Multi-step: "box 100x50x30 with a 20mm hole and 5mm fillet"
+ * - Gemini 2.0 Flash (free tier) + Groq Llama + smart local fallback
+ * - Command history with ArrowUp/Down (last 20, persisted)
  */
 
 // ============================================================================
@@ -11,90 +17,43 @@
 // ============================================================================
 
 const PART_TYPE_SYNONYMS = {
-  // Primitives
-  cube: ['cube', 'box', 'block', 'square block', 'rectangular block'],
-  box: ['box', 'rectangular box', 'cuboid'],
-  cylinder: ['cylinder', 'rod', 'post', 'pin', 'shaft', 'tube'],
-  sphere: ['sphere', 'ball', 'round', 'globe'],
-  cone: ['cone', 'conical'],
-
-  // Plates & Flats
-  plate: ['plate', 'flat plate', 'mounting plate', 'base plate', 'flat base'],
-  washer: ['washer', 'flat washer', 'ring'],
-  spacer: ['spacer', 'shim', 'ring spacer'],
-
-  // Mechanical Parts
-  bracket: ['bracket', 'L-bracket', 'angle bracket', 'support bracket', 'corner bracket'],
-  flange: ['flange', 'flanged bearing', 'flanged housing', 'hub'],
-  bearing: ['bearing', 'ball bearing', 'roller bearing'],
-  gear: ['gear', 'spur gear', 'pinion', 'toothed wheel'],
-  pulley: ['pulley', 'wheel', 'sheave'],
-  fastener: ['bolt', 'screw', 'stud', 'pin', 'rivet'],
-  housing: ['housing', 'enclosure', 'case', 'body'],
+  cube: ['cube', 'box', 'block', 'square', 'square block', 'rectangular block', 'cuboid', 'qube', 'boks', 'sqare', 'squere'],
+  cylinder: ['cylinder', 'cylindr', 'cylindre', 'cylnder', 'cyliner', 'rod', 'post', 'pin', 'shaft', 'tube', 'pipe', 'bar', 'piston', 'axle'],
+  sphere: ['sphere', 'spehre', 'shere', 'spehere', 'ball', 'round', 'globe', 'orb'],
+  cone: ['cone', 'conical', 'funnel', 'tapered'],
+  plate: ['plate', 'plat', 'flat plate', 'mounting plate', 'base plate', 'flat base', 'slab', 'panel'],
+  washer: ['washer', 'wahser', 'flat washer'],
+  spacer: ['spacer', 'spacr', 'shim', 'ring spacer', 'standoff', 'bushing'],
+  bracket: ['bracket', 'brcket', 'braket', 'brackt', 'L-bracket', 'angle bracket', 'support bracket', 'corner bracket', 'L bracket', 'angle iron'],
+  flange: ['flange', 'flnge', 'flanged bearing', 'flanged housing', 'hub', 'collar'],
+  gear: ['gear', 'geer', 'spur gear', 'pinion', 'toothed wheel', 'cog', 'sprocket'],
+  torus: ['torus', 'torous', 'donut', 'doughnut', 'ring', 'o-ring'],
 };
 
-const DIMENSION_KEYWORDS = {
-  radius: ['radius', 'r', 'rad'],
-  diameter: ['diameter', 'd', 'dia', 'od', 'outer diameter', 'id', 'inner diameter'],
-  height: ['height', 'h', 'tall', 'thickness'],
-  width: ['width', 'w', 'wide'],
-  depth: ['depth', 'dp'],
-  length: ['length', 'l', 'long'],
-  thickness: ['thickness', 'thick', 't'],
-  count: ['count', 'number of', 'qty', 'quantity'],
-  teeth: ['teeth', 'tooth', 'tooth count'],
-  angle: ['angle', 'degrees', 'deg'],
-};
-
-const OPERATION_KEYWORDS = {
-  fillet: ['fillet', 'round', 'rounded edge'],
-  chamfer: ['chamfer', 'beveled edge', 'bevel'],
-  hole: ['hole', 'bore', 'drill', 'perforation'],
-  cut: ['cut', 'remove', 'subtract', 'pocket'],
-  extrude: ['extrude', 'extend', 'raise', 'pull'],
-  revolve: ['revolve', 'rotate', 'sweep', 'spin'],
-  pattern: ['pattern', 'array', 'repeat', 'duplicate'],
-  mirror: ['mirror', 'flip', 'symmetric'],
-};
-
-const UNIT_FACTORS = {
-  mm: 1,
-  m: 1000,
-  cm: 10,
-  in: 25.4,
-  inch: 25.4,
-  ft: 304.8,
-  foot: 304.8,
-};
+const UNIT_FACTORS = { mm: 1, m: 1000, cm: 10, in: 25.4, inch: 25.4, ft: 304.8, foot: 304.8 };
 
 // ============================================================================
-// STATE MANAGEMENT
+// STATE
 // ============================================================================
 
 let chatState = {
   messages: [],
+  conversationHistory: [], // for LLM context
   messagesEl: null,
   inputEl: null,
   sendBtn: null,
   onCommand: null,
-  apiKeys: {
-    gemini: null,
-    groq: null,
-  },
+  apiKeys: { gemini: null, groq: null },
   isLoading: false,
+  commandHistory: [],
+  historyIndex: -1,
+  tempInput: '',
 };
 
 // ============================================================================
 // INITIALIZATION
 // ============================================================================
 
-/**
- * Initialize chat UI and wire up event handlers
- * @param {HTMLElement} messagesEl - Container for chat messages
- * @param {HTMLElement} inputEl - Input field for user messages
- * @param {HTMLElement} sendBtn - Send button
- * @param {Function} onCommand - Callback for parsed CAD commands
- */
 export function initChat(messagesEl, inputEl, sendBtn, onCommand) {
   chatState.messagesEl = messagesEl;
   chatState.inputEl = inputEl;
@@ -104,852 +63,1065 @@ export function initChat(messagesEl, inputEl, sendBtn, onCommand) {
   // Load stored API keys
   const stored = localStorage.getItem('cyclecad_api_keys');
   if (stored) {
-    try {
-      chatState.apiKeys = JSON.parse(stored);
-    } catch (e) {
-      console.warn('Failed to load stored API keys:', e);
-    }
+    try { chatState.apiKeys = JSON.parse(stored); } catch (e) {}
   }
 
-  // Wire up send button
-  if (sendBtn) {
-    sendBtn.addEventListener('click', () => handleSendMessage());
-  }
+  // Send button
+  if (sendBtn) sendBtn.addEventListener('click', () => handleSendMessage());
+
+  // Command history (last 20 commands, persisted)
+  chatState.commandHistory = JSON.parse(localStorage.getItem('cyclecad_chat_history') || '[]').slice(-20);
+  chatState.historyIndex = -1;
+  chatState.tempInput = '';
 
-  // Wire up input field Enter key
+  // Wire up input field Enter + ArrowUp/Down history
   if (inputEl) {
     inputEl.addEventListener('keydown', (e) => {
       if (e.key === 'Enter' && !e.shiftKey) {
         e.preventDefault();
         handleSendMessage();
+      } else if (e.key === 'ArrowUp') {
+        e.preventDefault();
+        const hist = chatState.commandHistory;
+        if (hist.length === 0) return;
+        if (chatState.historyIndex === -1) {
+          chatState.tempInput = inputEl.value;
+          chatState.historyIndex = hist.length - 1;
+        } else if (chatState.historyIndex > 0) {
+          chatState.historyIndex--;
+        }
+        inputEl.value = hist[chatState.historyIndex] || '';
+        setTimeout(() => inputEl.setSelectionRange(inputEl.value.length, inputEl.value.length), 0);
+      } else if (e.key === 'ArrowDown') {
+        e.preventDefault();
+        const hist = chatState.commandHistory;
+        if (chatState.historyIndex === -1) return;
+        if (chatState.historyIndex < hist.length - 1) {
+          chatState.historyIndex++;
+          inputEl.value = hist[chatState.historyIndex] || '';
+        } else {
+          chatState.historyIndex = -1;
+          inputEl.value = chatState.tempInput || '';
+        }
+        setTimeout(() => inputEl.setSelectionRange(inputEl.value.length, inputEl.value.length), 0);
       }
     });
   }
 
-  addMessage('ai', 'Hello! I\'m your CAD assistant. Describe the part you want to create, and I\'ll generate CAD commands. Try things like: "50mm cube", "cylinder 30mm radius 60mm tall", or "bracket 80x40x5".');
+  addMessage('ai', 'Hi! I\'m your CAD assistant. I can create parts, modify them, and answer questions.\n\nTry: "cylinder 50mm diameter 80 tall", "bracket 80x40x5", "remove it", "undo", or "what can you do?"');
 }
 
-/**
- * Handle sending a user message
- */
+// ============================================================================
+// MESSAGE HANDLING
+// ============================================================================
+
 async function handleSendMessage() {
   const text = chatState.inputEl?.value.trim();
   if (!text) return;
 
-  // Clear input and add user message
-  if (chatState.inputEl) {
-    chatState.inputEl.value = '';
-  }
+  // Save to command history
+  chatState.commandHistory.push(text);
+  if (chatState.commandHistory.length > 20) chatState.commandHistory.shift();
+  chatState.historyIndex = -1;
+  chatState.tempInput = '';
+  try { localStorage.setItem('cyclecad_chat_history', JSON.stringify(chatState.commandHistory)); } catch(e) {}
+
+  if (chatState.inputEl) chatState.inputEl.value = '';
   addMessage('user', text);
 
-  // Show loading state
   chatState.isLoading = true;
-  if (chatState.sendBtn) {
-    chatState.sendBtn.disabled = true;
-  }
+  if (chatState.sendBtn) chatState.sendBtn.disabled = true;
 
   try {
-    // Parse CAD commands
-    const commands = await parseCADPrompt(text);
-
-    if (commands && commands.length > 0) {
-      // Generate AI response
-      const response = commands
-        .map((cmd) => generateDescription(cmd))
-        .join(', ');
+    const result = await processMessage(text);
 
-      addMessage('ai', `Got it! ${response}`);
+    if (result.reply) {
+      addMessage('ai', result.reply);
+    }
 
-      // Call callback for each command
-      if (chatState.onCommand) {
-        commands.forEach((cmd) => chatState.onCommand(cmd));
-      }
-    } else {
-      addMessage('ai', 'I couldn\'t parse that description. Try being more specific: "100x60x20 box", "cylinder r30 h60", "add a 10mm fillet", etc.');
+    if (result.commands && result.commands.length > 0 && chatState.onCommand) {
+      result.commands.forEach(cmd => chatState.onCommand(cmd));
     }
   } catch (error) {
     console.error('Chat error:', error);
-    addMessage('ai', 'Sorry, I encountered an error. Please try again.');
+    addMessage('ai', 'Something went wrong. Try again or rephrase your request.');
   } finally {
     chatState.isLoading = false;
-    if (chatState.sendBtn) {
-      chatState.sendBtn.disabled = false;
-    }
+    if (chatState.sendBtn) chatState.sendBtn.disabled = false;
   }
 }
 
-/**
- * Add a message to the chat
- * @param {string} role - 'user' or 'ai'
- * @param {string} text - Message text
- */
 export function addMessage(role, text) {
   chatState.messages.push({ role, text });
 
+  // Keep conversation history for LLM context (last 10 turns)
+  chatState.conversationHistory.push({ role: role === 'ai' ? 'model' : 'user', text });
+  if (chatState.conversationHistory.length > 20) chatState.conversationHistory.splice(0, 2);
+
   if (!chatState.messagesEl) return;
 
   const msgDiv = document.createElement('div');
   msgDiv.className = `chat-message chat-message-${role}`;
-  msgDiv.textContent = text;
+  // Support basic formatting
+  msgDiv.innerHTML = text
+    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+    .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
+    .replace(/\n/g, '<br>');
 
   chatState.messagesEl.appendChild(msgDiv);
   chatState.messagesEl.scrollTop = chatState.messagesEl.scrollHeight;
 }
 
 // ============================================================================
-// MAIN PARSING ENGINE
+// FUZZY ACTION KEYWORD MATCHING
 // ============================================================================
 
-/**
- * Parse natural language into CAD commands
- * @param {string} text - Natural language description
- * @returns {Promise<Array>} Array of CAD command objects
- */
-export async function parseCADPrompt(text) {
-  text = text.toLowerCase().trim();
+const ACTION_KEYWORDS = {
+  intersect: ['intersect', 'interset', 'intersec', 'interect', 'intersct', 'intesect', 'inersect', 'intersekt', 'intersection', 'overlap'],
+  subtract: ['subtract', 'subtrat', 'substract', 'subract', 'subtarct', 'subt', 'cut', 'difference', 'minus'],
+  union: ['union', 'combine', 'merge', 'join', 'fuse', 'unoin', 'uniom'],
+  delete: ['delete', 'delet', 'deleet', 'remove', 'remov', 'erase', 'trash', 'destroy', 'get rid of'],
+  move: ['move', 'mov', 'shift', 'translate', 'drag', 'push', 'pull', 'nudge'],
+  rotate: ['rotate', 'rotat', 'rotaet', 'spin', 'turn', 'twist'],
+  scale: ['scale', 'scael', 'resize', 'bigger', 'smaller', 'larger', 'grow', 'shrink'],
+  duplicate: ['duplicate', 'duplicat', 'copy', 'clone'],
+  hide: ['hide', 'hid', 'invisible'],
+  undo: ['undo', 'unod', 'undoo'],
+  redo: ['redo', 'redoo'],
+  fillet: ['fillet', 'filet', 'fillt', 'round edge', 'rounded'],
+  chamfer: ['chamfer', 'chamfr', 'chamfar', 'bevel'],
+  color: ['color', 'colour', 'paint', 'material'],
+  export: ['export', 'exprot', 'exprt', 'download', 'save as'],
+};
 
-  // Try LLM first if available
-  if (chatState.apiKeys.gemini || chatState.apiKeys.groq) {
-    try {
-      const llmCommands = await queryLLM(text);
-      if (llmCommands && llmCommands.length > 0) {
-        return llmCommands;
-      }
-    } catch (error) {
-      console.warn('LLM query failed, falling back to local parser:', error);
+function fuzzyMatchAction(text) {
+  const lower = text.toLowerCase();
+  // 1. Direct keyword match
+  for (const [action, keywords] of Object.entries(ACTION_KEYWORDS)) {
+    for (const kw of keywords) {
+      if (lower.includes(kw)) return action;
     }
   }
-
-  // Fall back to local parsing
-  return localParseCADPrompt(text);
-}
-
-/**
- * Local parsing fallback (no LLM required)
- */
-function localParseCADPrompt(text) {
-  const commands = [];
-
-  // Detect primary part type
-  const partType = detectPartType(text);
-  const numbers = parseNumbers(text);
-  const dims = parseDimensions(text);
-
-  // Handle primitives
-  if (partType === 'cube' || partType === 'box') {
-    const cmd = parseBoxCommand(text, numbers, dims);
-    if (cmd) commands.push(cmd);
-  } else if (partType === 'cylinder') {
-    const cmd = parseCylinderCommand(text, numbers);
-    if (cmd) commands.push(cmd);
-  } else if (partType === 'sphere') {
-    const cmd = parseSphereCommand(text, numbers);
-    if (cmd) commands.push(cmd);
-  } else if (partType === 'cone') {
-    const cmd = parseConeCommand(text, numbers);
-    if (cmd) commands.push(cmd);
-  }
-
-  // Handle mechanical parts
-  if (partType === 'plate') {
-    const cmd = parsePlateCommand(text, numbers, dims);
-    if (cmd) commands.push(cmd);
-  } else if (partType === 'bracket') {
-    const cmd = parseBracketCommand(text, numbers, dims);
-    if (cmd) commands.push(cmd);
-  } else if (partType === 'flange') {
-    const cmd = parseFlangeCommand(text, numbers);
-    if (cmd) commands.push(cmd);
-  } else if (partType === 'washer') {
-    const cmd = parseWasherCommand(text, numbers);
-    if (cmd) commands.push(cmd);
-  } else if (partType === 'spacer') {
-    const cmd = parseSpacerCommand(text, numbers);
-    if (cmd) commands.push(cmd);
-  } else if (partType === 'gear') {
-    const cmd = parseGearCommand(text, numbers);
-    if (cmd) commands.push(cmd);
-  }
-
-  // Handle operations (holes, fillets, etc.)
-  parseOperations(text, numbers, commands);
-
-  return commands;
+  // 2. Levenshtein fuzzy match on individual words
+  const words = lower.replace(/[^a-z\s]/g, '').split(/\s+/).filter(w => w.length >= 3);
+  const targets = [];
+  for (const [action, keywords] of Object.entries(ACTION_KEYWORDS)) {
+    for (const kw of keywords) {
+      if (!kw.includes(' ')) targets.push({ word: kw, action });
+    }
+  }
+  let best = null, bestDist = Infinity;
+  for (const w of words) {
+    for (const t of targets) {
+      const d = levenshtein(w, t.word);
+      const threshold = t.word.length <= 4 ? 1 : 2;
+      if (d <= threshold && d < bestDist) { bestDist = d; best = t.action; }
+    }
+  }
+  return best;
 }
 
 // ============================================================================
-// PRIMITIVE PARSERS
+// SMART MESSAGE PROCESSING
 // ============================================================================
 
-/**
- * Parse box/cube command
- */
-function parseBoxCommand(text, numbers, dims) {
-  let width, height, depth;
-
-  if (dims.length === 3) {
-    [width, height, depth] = dims;
-  } else if (dims.length === 1) {
-    // Assume cube
-    width = height = depth = dims[0];
-  } else if (numbers.length >= 3) {
-    width = numbers[0];
-    height = numbers[1];
-    depth = numbers[2];
-  } else if (numbers.length === 1) {
-    width = height = depth = numbers[0];
-  } else {
-    return null;
+async function processMessage(text) {
+  const lower = text.toLowerCase().trim();
+
+  // 1. Check for scene action commands (delete, undo, move, etc.)
+  const actionResult = handleSceneAction(lower, text);
+  if (actionResult) return actionResult;
+
+  // 1b. Fuzzy action matching — catches typos like "interset", "subtrat", "deleet"
+  const fuzzyAction = fuzzyMatchAction(lower);
+  if (fuzzyAction) {
+    const corrected = lower.replace(
+      new RegExp(lower.split(/\s+/).find(w => {
+        for (const kw of (ACTION_KEYWORDS[fuzzyAction] || [])) {
+          if (levenshtein(w, kw) <= 2) return true;
+        }
+        return false;
+      }) || '', 'i'),
+      fuzzyAction
+    );
+    const retryResult = handleSceneAction(corrected, text);
+    if (retryResult) return retryResult;
   }
 
-  return {
-    type: 'box',
-    width: Math.round(width * 10) / 10,
-    height: Math.round(height * 10) / 10,
-    depth: Math.round(depth * 10) / 10,
-  };
-}
-
-/**
- * Parse cylinder command
- */
-function parseCylinderCommand(text, numbers) {
-  let radius, height;
+  // 2. Check for questions / conversational messages
+  const conversationalReply = handleConversational(lower, text);
+  if (conversationalReply) return { reply: conversationalReply, commands: [] };
 
-  // Try to extract radius and height from keywords
-  if (text.match(/radius|r\s*(\d+)|rod/i)) {
-    const rMatch = text.match(/radius\s*(\d+(?:\.\d+)?)|r\s*(\d+(?:\.\d+)?)/i);
-    if (rMatch) {
-      radius = parseFloat(rMatch[1] || rMatch[2]);
-    }
-  }
-
-  if (text.match(/height|h\s*(\d+)|tall/i)) {
-    const hMatch = text.match(/height\s*(\d+(?:\.\d+)?)|h\s*(\d+(?:\.\d+)?)/i);
-    if (hMatch) {
-      height = parseFloat(hMatch[1] || hMatch[2]);
+  // 3. Try LLM if API key available
+  if (chatState.apiKeys.gemini || chatState.apiKeys.groq) {
+    try {
+      const llmResult = await querySmartLLM(text);
+      if (llmResult) return llmResult;
+    } catch (e) {
+      console.warn('LLM failed, using local parser:', e.message);
     }
   }
 
-  // Fall back to first two numbers
-  if (!radius && !height && numbers.length >= 2) {
-    radius = numbers[0];
-    height = numbers[1];
-  } else if (!radius && numbers.length >= 1) {
-    radius = numbers[0];
-    height = radius;
-  }
-
-  if (!radius || !height) {
-    return null;
+  // 4. Smart local parsing for creation commands
+  const commands = localParseCADPrompt(lower);
+  if (commands.length > 0) {
+    const desc = commands.map(c => generateDescription(c)).join(', then ');
+    return { reply: `Creating: ${desc}`, commands };
   }
 
+  // 5. Nothing matched — give helpful response
   return {
-    type: 'cylinder',
-    radius: Math.round(radius * 10) / 10,
-    height: Math.round(height * 10) / 10,
+    reply: `I didn't understand "${text}". Here's what I can do:\n\n**Create:** "box 100x50x30", "cylinder r25 h60", "bracket 80x40x5"\n**Modify:** "remove it", "delete the box", "undo", "redo"\n**Transform:** "move it up 20", "rotate 45", "scale 2x"\n**Operations:** "fillet 5mm", "chamfer 3mm"\n**Booleans:** "subtract box from cylinder", "intersect"\n**Scene:** "hide it", "show all", "select the cylinder", "clear scene"\n**Questions:** "what shapes can you make?", "what's in the scene?"`,
+    commands: []
   };
 }
 
-/**
- * Parse sphere command
- */
-function parseSphereCommand(text, numbers) {
-  let radius;
+// ============================================================================
+// SCENE ACTION HANDLER (delete, undo, move, hide, booleans, etc.)
+// ============================================================================
 
-  if (numbers.length >= 1) {
-    const val = numbers[0];
-    // Check if it's diameter or radius
-    if (text.match(/diameter|dia|d\s*(\d+)/i)) {
-      radius = val / 2;
-    } else {
-      radius = val;
+function handleSceneAction(lower, original) {
+  const features = window.APP?.features || [];
+  const selectedIdx = window.APP?.selectedFeatureIndex ?? -1;
+
+  // --- DELETE / REMOVE ---
+  if (/^(delet|delete|remov|remove|erase|trash|get rid of|destroy)\w*\b/.test(lower) ||
+      /\b(delet|delete|remov|remove|erase)\w*\s+(it|this|that|the last|last|selected|current)\b/.test(lower) ||
+      /^(remove|delete|remov|delet)\w*\s+it\s*$/.test(lower)) {
+
+    // Find which part to delete
+    const targetIdx = resolveTarget(lower, features, selectedIdx);
+    if (targetIdx >= 0 && targetIdx < features.length) {
+      const name = features[targetIdx].name || 'Part';
+      return {
+        reply: `Removed "${name}".`,
+        commands: [{ action: 'delete', index: targetIdx }]
+      };
     }
+    if (features.length > 0) {
+      // Default: remove last part
+      const last = features[features.length - 1];
+      return {
+        reply: `Removed "${last.name || 'last part'}".`,
+        commands: [{ action: 'delete', index: features.length - 1 }]
+      };
+    }
+    return { reply: 'Nothing to remove — the scene is empty.', commands: [] };
   }
 
-  if (!radius) {
-    return null;
+  // --- UNDO ---
+  if (/^undo\s*$/.test(lower) || /^(ctrl\+?z|go back|step back)\s*$/.test(lower)) {
+    return { reply: 'Undone.', commands: [{ action: 'undo' }] };
   }
 
-  return {
-    type: 'sphere',
-    radius: Math.round(radius * 10) / 10,
-  };
-}
-
-/**
- * Parse cone command
- */
-function parseConeCommand(text, numbers) {
-  let radius, height;
-
-  if (numbers.length >= 2) {
-    radius = numbers[0];
-    height = numbers[1];
-  } else if (numbers.length === 1) {
-    radius = numbers[0];
-    height = radius;
+  // --- REDO ---
+  if (/^redo\s*$/.test(lower) || /^(ctrl\+?y|step forward)\s*$/.test(lower)) {
+    return { reply: 'Redone.', commands: [{ action: 'redo' }] };
   }
 
-  if (!radius || !height) {
-    return null;
+  // --- CLEAR SCENE ---
+  if (/^(clear|clean|empty|reset)\s*(scene|all|everything|viewport)?\s*$/.test(lower)) {
+    return { reply: 'Scene cleared.', commands: [{ action: 'clearScene' }] };
   }
 
-  return {
-    type: 'cone',
-    radius: Math.round(radius * 10) / 10,
-    height: Math.round(height * 10) / 10,
-  };
-}
+  // --- HIDE ---
+  if (/^hide\b/.test(lower) || /\bhide\s+(it|this|that|selected|the)\b/.test(lower)) {
+    const targetIdx = resolveTarget(lower, features, selectedIdx);
+    const idx = targetIdx >= 0 ? targetIdx : (selectedIdx >= 0 ? selectedIdx : features.length - 1);
+    if (idx >= 0 && idx < features.length) {
+      return {
+        reply: `Hidden "${features[idx].name || 'Part'}".`,
+        commands: [{ action: 'hide', index: idx }]
+      };
+    }
+    return { reply: 'Nothing to hide.', commands: [] };
+  }
 
-// ============================================================================
-// MECHANICAL PART PARSERS
-// ============================================================================
+  // --- SHOW ALL ---
+  if (/^show\s*all\s*$/.test(lower) || /^unhide\s*all\s*$/.test(lower)) {
+    return { reply: 'All parts visible.', commands: [{ action: 'showAll' }] };
+  }
 
-/**
- * Parse plate command
- */
-function parsePlateCommand(text, numbers, dims) {
-  let width, depth, thickness;
+  // --- SELECT ---
+  if (/^select\b/.test(lower)) {
+    const targetIdx = resolveTarget(lower, features, selectedIdx);
+    if (targetIdx >= 0) {
+      return {
+        reply: `Selected "${features[targetIdx].name || 'Part'}".`,
+        commands: [{ action: 'select', index: targetIdx }]
+      };
+    }
+    return { reply: 'Could not find that part. Use "what\'s in the scene?" to see available parts.', commands: [] };
+  }
 
-  if (dims.length >= 3) {
-    width = dims[0];
-    depth = dims[1];
-    thickness = dims[2];
-  } else if (dims.length === 2) {
-    width = dims[0];
-    depth = dims[1];
-    thickness = 5; // default
-  } else if (numbers.length >= 3) {
-    width = numbers[0];
-    depth = numbers[1];
-    thickness = numbers[2];
-  } else if (numbers.length >= 2) {
-    width = numbers[0];
-    depth = numbers[1];
-    thickness = 5;
-  }
-
-  if (!width || !depth) {
-    return null;
-  }
-
-  const cmd = {
-    type: 'box',
-    width: Math.round(width * 10) / 10,
-    height: Math.round(thickness * 10) / 10,
-    depth: Math.round(depth * 10) / 10,
-  };
+  // --- MOVE ---
+  if (/^move\b/.test(lower) || /\bmove\s+(it|this|that|the)\b/.test(lower)) {
+    const dir = parseDirection(lower);
+    const dist = parseFirstNumber(lower) || 20;
+    const targetIdx = resolveTarget(lower, features, selectedIdx);
+    const idx = targetIdx >= 0 ? targetIdx : (selectedIdx >= 0 ? selectedIdx : features.length - 1);
+    if (idx >= 0 && idx < features.length) {
+      return {
+        reply: `Moved "${features[idx].name || 'Part'}" ${dir.label} by ${dist}mm.`,
+        commands: [{ action: 'move', index: idx, axis: dir.axis, distance: dist * dir.sign }]
+      };
+    }
+    return { reply: 'Nothing to move.', commands: [] };
+  }
 
-  // Parse hole pattern
-  const holePattern = parseHolePattern(text);
-  if (holePattern) {
-    cmd.holes = holePattern;
+  // --- ROTATE ---
+  if (/^rotate\b/.test(lower) || /\brotate\s+(it|this|that|the)\b/.test(lower)) {
+    const angle = parseFirstNumber(lower) || 90;
+    const axis = /\b[xX]\b/.test(lower) ? 'x' : /\b[zZ]\b/.test(lower) ? 'z' : 'y';
+    const targetIdx = resolveTarget(lower, features, selectedIdx);
+    const idx = targetIdx >= 0 ? targetIdx : (selectedIdx >= 0 ? selectedIdx : features.length - 1);
+    if (idx >= 0 && idx < features.length) {
+      return {
+        reply: `Rotated "${features[idx].name || 'Part'}" ${angle}° around ${axis.toUpperCase()}.`,
+        commands: [{ action: 'rotate', index: idx, axis, angle }]
+      };
+    }
+    return { reply: 'Nothing to rotate.', commands: [] };
   }
 
-  return cmd;
-}
+  // --- MODIFY / RESIZE / CHANGE DIMENSION ---
+  // "reduce the height to 20", "set width to 50", "change radius to 15", "make it 30mm tall"
+  if (/\b(reduce|increase|set|change|make|adjust|modify)\b.*\b(height|width|depth|radius|diameter|size|thickness|tall|wide|long|high)\b/.test(lower) ||
+      /\b(height|width|depth|radius|diameter|thickness)\s*(to|=)\s*\d/.test(lower)) {
+    const val = parseFirstNumber(lower.replace(/.*?(to|=)\s*/i, 'to '));
+    const num = val || parseFirstNumber(lower);
+    if (num > 0) {
+      const targetIdx = resolveTarget(lower, features, selectedIdx);
+      const idx = targetIdx >= 0 ? targetIdx : (selectedIdx >= 0 ? selectedIdx : features.length - 1);
+      if (idx >= 0 && idx < features.length) {
+        const f = features[idx];
+        // Determine which dimension to change
+        let dim = 'height';
+        if (/\b(width|wide)\b/.test(lower)) dim = 'width';
+        else if (/\b(depth|deep|long|length)\b/.test(lower)) dim = 'depth';
+        else if (/\b(radius|rad)\b/.test(lower)) dim = 'radius';
+        else if (/\b(diameter|dia)\b/.test(lower)) dim = 'diameter';
+        else if (/\b(thickness|thick)\b/.test(lower)) dim = 'thickness';
+        else if (/\b(height|tall|high)\b/.test(lower)) dim = 'height';
+        else if (/\b(size)\b/.test(lower)) dim = 'size';
+
+        return {
+          reply: `Changed ${dim} of "${f.name || 'Part'}" to ${num}mm.`,
+          commands: [{ action: 'modifyDimension', index: idx, dimension: dim, value: num }]
+        };
+      }
+    }
+  }
 
-/**
- * Parse bracket command
- */
-function parseBracketCommand(text, numbers, dims) {
-  let width, height, thickness;
+  // --- SCALE / MAKE BIGGER/SMALLER ---
+  if (/\b(scale|bigger|smaller|larger|resize|grow|shrink)\b/.test(lower) ||
+      /\bmake\s+it\s+(bigger|smaller|larger|taller|shorter|wider|thinner)\b/.test(lower)) {
+    let factor = parseFirstNumber(lower);
+    if (!factor) {
+      if (/bigger|larger|grow|taller|wider/i.test(lower)) factor = 1.5;
+      else if (/smaller|shrink|shorter|thinner/i.test(lower)) factor = 0.67;
+      else factor = 1.5;
+    }
+    // If user said "scale 2x" or "2x bigger"
+    if (/(\d+(?:\.\d+)?)\s*x\b/.test(lower)) {
+      factor = parseFloat(lower.match(/(\d+(?:\.\d+)?)\s*x\b/)[1]);
+    }
+    const targetIdx = resolveTarget(lower, features, selectedIdx);
+    const idx = targetIdx >= 0 ? targetIdx : (selectedIdx >= 0 ? selectedIdx : features.length - 1);
+    if (idx >= 0 && idx < features.length) {
+      return {
+        reply: `Scaled "${features[idx].name || 'Part'}" by ${factor}x.`,
+        commands: [{ action: 'scale', index: idx, factor }]
+      };
+    }
+    return { reply: 'Nothing to scale.', commands: [] };
+  }
 
-  if (dims.length >= 3) {
-    width = dims[0];
-    height = dims[1];
-    thickness = dims[2];
-  } else if (numbers.length >= 3) {
-    width = numbers[0];
-    height = numbers[1];
-    thickness = numbers[2];
+  // --- DUPLICATE / COPY ---
+  if (/^(duplicate|copy|clone)\b/.test(lower)) {
+    const targetIdx = resolveTarget(lower, features, selectedIdx);
+    const idx = targetIdx >= 0 ? targetIdx : (selectedIdx >= 0 ? selectedIdx : features.length - 1);
+    if (idx >= 0 && idx < features.length) {
+      return {
+        reply: `Duplicated "${features[idx].name || 'Part'}".`,
+        commands: [{ action: 'duplicate', index: idx }]
+      };
+    }
+    return { reply: 'Nothing to duplicate.', commands: [] };
   }
 
-  if (!width || !height) {
-    return null;
+  // --- BOOLEAN OPERATIONS (subtract / intersect / union) ---
+  // Detect boolean intent via exact match OR fuzzy
+  const booleanOp = detectBooleanOp(lower);
+  if (booleanOp) {
+    return handleBoolean(booleanOp, lower, features, selectedIdx);
   }
 
-  return {
-    type: 'bracket',
-    width: Math.round(width * 10) / 10,
-    height: Math.round(height * 10) / 10,
-    thickness: Math.round((thickness || 5) * 10) / 10,
-  };
-}
+  // --- COLOR / MATERIAL ---
+  if (/\b(color|colour|paint|material)\b/.test(lower)) {
+    const colorMatch = lower.match(/\b(red|green|blue|yellow|orange|purple|white|black|gray|grey|silver|gold|pink|cyan|magenta)\b/);
+    if (colorMatch) {
+      const targetIdx = resolveTarget(lower, features, selectedIdx);
+      const idx = targetIdx >= 0 ? targetIdx : (selectedIdx >= 0 ? selectedIdx : features.length - 1);
+      if (idx >= 0 && idx < features.length) {
+        return {
+          reply: `Changed color of "${features[idx].name || 'Part'}" to ${colorMatch[1]}.`,
+          commands: [{ action: 'color', index: idx, color: colorMatch[1] }]
+        };
+      }
+    }
+    return { reply: 'Specify a color: "color it red", "make it blue", "paint the box green".', commands: [] };
+  }
 
-/**
- * Parse flange command
- */
-function parseFlangeCommand(text, numbers) {
-  let outerDiameter, innerDiameter, height, boltCount;
+  // --- RENAME ---
+  if (/^rename\b/.test(lower)) {
+    const nameMatch = original.match(/rename\s+(?:it\s+)?(?:to\s+)?["']?([^"']+?)["']?\s*$/i);
+    if (nameMatch) {
+      const idx = selectedIdx >= 0 ? selectedIdx : features.length - 1;
+      if (idx >= 0 && idx < features.length) {
+        return {
+          reply: `Renamed to "${nameMatch[1].trim()}".`,
+          commands: [{ action: 'rename', index: idx, name: nameMatch[1].trim() }]
+        };
+      }
+    }
+    return { reply: 'Usage: "rename to My Part Name"', commands: [] };
+  }
 
-  // OD first
-  const odMatch = text.match(/od\s*(\d+(?:\.\d+)?)|outer\s*diameter\s*(\d+(?:\.\d+)?)/i);
-  if (odMatch) {
-    outerDiameter = parseFloat(odMatch[1] || odMatch[2]);
-  } else if (numbers.length >= 1) {
-    outerDiameter = numbers[0];
+  // --- FIT VIEW / ZOOM TO FIT ---
+  if (/^(fit|zoom to fit|fit all|zoom all|reset view|home view|reset camera)\s*$/.test(lower)) {
+    return { reply: 'View reset.', commands: [{ action: 'fitAll' }] };
   }
 
-  // ID
-  const idMatch = text.match(/id\s*(\d+(?:\.\d+)?)|inner\s*diameter\s*(\d+(?:\.\d+)?)/i);
-  if (idMatch) {
-    innerDiameter = parseFloat(idMatch[1] || idMatch[2]);
-  } else if (numbers.length >= 2) {
-    innerDiameter = numbers[1];
+  // --- WIREFRAME ---
+  if (/^(wireframe|toggle wireframe)\s*$/.test(lower)) {
+    return { reply: 'Wireframe toggled.', commands: [{ action: 'wireframe' }] };
   }
 
-  // Height
-  const hMatch = text.match(/height\s*(\d+(?:\.\d+)?)|h\s*(\d+(?:\.\d+)?)|tall\s*(\d+(?:\.\d+)?)/i);
-  if (hMatch) {
-    height = parseFloat(hMatch[1] || hMatch[2] || hMatch[3]);
-  } else if (numbers.length >= 3) {
-    height = numbers[2];
+  // --- GRID ---
+  if (/^(grid|toggle grid)\s*$/.test(lower)) {
+    return { reply: 'Grid toggled.', commands: [{ action: 'grid' }] };
   }
 
-  // Bolt count
-  const boltMatch = text.match(/(\d+)\s*bolt/i);
-  if (boltMatch) {
-    boltCount = parseInt(boltMatch[1]);
+  // --- EXPORT ---
+  if (/^export\b/.test(lower)) {
+    const fmt = /stl/i.test(lower) ? 'stl' : /obj/i.test(lower) ? 'obj' : /gltf|glb/i.test(lower) ? 'gltf' : /dxf/i.test(lower) ? 'dxf' : /json/i.test(lower) ? 'json' : 'stl';
+    return { reply: `Exporting as ${fmt.toUpperCase()}...`, commands: [{ action: 'export', format: fmt }] };
   }
 
-  if (!outerDiameter) {
-    return null;
+  // --- SKETCH TOOLS ---
+  if (/^(start|begin|new)\s*sketch\s*$/i.test(lower) || /^sketch\s*$/i.test(lower)) {
+    return { reply: 'Starting sketch mode. Draw on the grid plane.', commands: [{ action: 'startSketch' }] };
+  }
+  if (/^(end|finish|done|close)\s*sketch\s*$/i.test(lower)) {
+    return { reply: 'Sketch completed.', commands: [{ action: 'endSketch' }] };
+  }
+  if (/^(draw\s+)?line\s*$/i.test(lower)) {
+    return { reply: 'Line tool active. Click to place points.', commands: [{ action: 'sketchTool', tool: 'line' }] };
+  }
+  if (/^(draw\s+)?rect(angle)?\s*$/i.test(lower)) {
+    return { reply: 'Rectangle tool active. Click to place corners.', commands: [{ action: 'sketchTool', tool: 'rect' }] };
+  }
+  if (/^(draw\s+)?circle\s*$/i.test(lower)) {
+    return { reply: 'Circle tool active. Click center, then radius.', commands: [{ action: 'sketchTool', tool: 'circle' }] };
+  }
+  if (/^(draw\s+)?arc\s*$/i.test(lower)) {
+    return { reply: 'Arc tool active. Click start, mid, end.', commands: [{ action: 'sketchTool', tool: 'arc' }] };
   }
 
-  return {
-    type: 'flange',
-    outerDiameter: Math.round(outerDiameter * 10) / 10,
-    innerDiameter: innerDiameter ? Math.round(innerDiameter * 10) / 10 : outerDiameter * 0.5,
-    height: height ? Math.round(height * 10) / 10 : 10,
-    boltCount: boltCount || 4,
-  };
-}
+  // --- 3D OPERATIONS ---
+  if (/^extrude\s*$/i.test(lower) || /^extrude\s+sketch\s*$/i.test(lower)) {
+    return { reply: 'Extruding sketch...', commands: [{ action: 'extrude' }] };
+  }
+  if (/^revolve\s*$/i.test(lower)) {
+    return { reply: 'Revolving sketch...', commands: [{ action: 'revolve' }] };
+  }
+  if (/^(cut|boolean cut)\s*$/i.test(lower)) {
+    return { reply: 'Cut mode active. Select tool body.', commands: [{ action: 'cut' }] };
+  }
 
-/**
- * Parse washer command
- */
-function parseWasherCommand(text, numbers) {
-  let outerDiameter, innerDiameter, thickness;
+  // --- ADVANCED OPERATIONS ---
+  if (/\b(sweep)\b/i.test(lower)) {
+    return { reply: 'Sweep operation. Select profile and path.', commands: [{ action: 'sweep' }] };
+  }
+  if (/\b(loft)\b/i.test(lower)) {
+    return { reply: 'Loft operation. Select profiles to blend.', commands: [{ action: 'loft' }] };
+  }
+  if (/\b(shell|hollow)\b/i.test(lower)) {
+    const t = parseFirstNumber(lower) || 2;
+    return { reply: `Shell with ${t}mm wall thickness.`, commands: [{ action: 'shell', thickness: t }] };
+  }
+  if (/\b(pattern|array)\b/i.test(lower)) {
+    const n = parseFirstNumber(lower) || 4;
+    return { reply: `Pattern: ${n} copies.`, commands: [{ action: 'pattern', count: n }] };
+  }
+  if (/\b(mirror)\b/i.test(lower)) {
+    const plane = /\b[xX]\b/.test(lower) ? 'x' : /\b[zZ]\b/.test(lower) ? 'z' : 'y';
+    return { reply: `Mirrored across ${plane.toUpperCase()} plane.`, commands: [{ action: 'mirror', plane }] };
+  }
+  if (/\b(thread)\b/i.test(lower)) {
+    return { reply: 'Adding thread to selected cylinder.', commands: [{ action: 'thread' }] };
+  }
+  if (/\b(spring)\b/i.test(lower)) {
+    const d = parseFirstNumber(lower) || 20;
+    return { reply: `Creating spring (d=${d}mm).`, commands: [{ action: 'spring', diameter: d }] };
+  }
 
-  // Try M-size matching (e.g., M10, M8)
-  const mMatch = text.match(/m(\d+)/i);
-  if (mMatch) {
-    const size = parseInt(mMatch[1]);
-    // Standard washer dimensions (approximate)
-    outerDiameter = size * 2.5;
-    innerDiameter = size + 0.5;
-    thickness = 2;
-  } else if (numbers.length >= 2) {
-    outerDiameter = numbers[0];
-    innerDiameter = numbers[1];
-    thickness = numbers[2] || 2;
+  // --- SHEET METAL ---
+  if (/\b(bend|sheet\s*metal\s*bend)\b/i.test(lower)) {
+    return { reply: 'Sheet metal bend.', commands: [{ action: 'bend' }] };
+  }
+  if (/\b(unfold|flat\s*pattern)\b/i.test(lower)) {
+    return { reply: 'Unfolding sheet metal to flat pattern.', commands: [{ action: 'unfold' }] };
   }
 
-  if (!outerDiameter || !innerDiameter) {
-    return null;
+  // --- VIEWS ---
+  if (/^(front|top|right|left|back|bottom|isometric|iso)\s*(view)?\s*$/i.test(lower)) {
+    const view = lower.replace(/\s*view\s*$/, '').trim();
+    return { reply: `${view.charAt(0).toUpperCase() + view.slice(1)} view.`, commands: [{ action: 'setView', view }] };
+  }
+  if (/\b(zoom\s*in)\b/i.test(lower)) {
+    return { reply: 'Zoomed in.', commands: [{ action: 'zoomIn' }] };
+  }
+  if (/\b(zoom\s*out)\b/i.test(lower)) {
+    return { reply: 'Zoomed out.', commands: [{ action: 'zoomOut' }] };
+  }
+  if (/\b(dark\s*mode|light\s*mode|toggle\s*theme)\b/i.test(lower)) {
+    return { reply: 'Theme toggled.', commands: [{ action: 'toggleTheme' }] };
   }
 
-  return {
-    type: 'washer',
-    outerDiameter: Math.round(outerDiameter * 10) / 10,
-    innerDiameter: Math.round(innerDiameter * 10) / 10,
-    thickness: Math.round(thickness * 10) / 10,
-  };
-}
+  // --- PANELS ---
+  if (/\b(open|show)\s*(help|keyboard|shortcuts)\b/i.test(lower)) {
+    return { reply: 'Opening help panel.', commands: [{ action: 'openPanel', panel: 'help' }] };
+  }
+  if (/\b(open|show)\s*(properties|params|parameters)\b/i.test(lower)) {
+    return { reply: 'Showing properties panel.', commands: [{ action: 'openPanel', panel: 'properties' }] };
+  }
+  if (/\b(open|show)\s*(guide|rebuild)\b/i.test(lower)) {
+    return { reply: 'Opening guide panel.', commands: [{ action: 'openPanel', panel: 'guide' }] };
+  }
+  if (/\b(open|show)\s*(token|billing)\b/i.test(lower)) {
+    return { reply: 'Opening tokens panel.', commands: [{ action: 'openPanel', panel: 'tokens' }] };
+  }
+  if (/\b(open|show)\s*(marketplace|store)\b/i.test(lower)) {
+    return { reply: 'Opening marketplace.', commands: [{ action: 'openPanel', panel: 'marketplace' }] };
+  }
+  if (/\b(open|show)\s*(gd&?t|gdt|tolerance)\b/i.test(lower)) {
+    return { reply: 'Opening GD&T training.', commands: [{ action: 'openPanel', panel: 'gdt' }] };
+  }
+  if (/\b(open|show)\s*(misumi|catalog)\b/i.test(lower)) {
+    return { reply: 'Opening MISUMI catalog.', commands: [{ action: 'openPanel', panel: 'misumi' }] };
+  }
+  if (/\b(open|show)\s*(console|log)\b/i.test(lower)) {
+    return { reply: 'Opening console.', commands: [{ action: 'openPanel', panel: 'console' }] };
+  }
 
-/**
- * Parse spacer command
- */
-function parseSpacerCommand(text, numbers) {
-  let outerDiameter, innerDiameter, height;
+  // --- IMPORT ---
+  if (/\b(import|open|load)\s*(step|stp|inventor|ipt|iam|stl|obj)\b/i.test(lower)) {
+    const format = /step|stp/i.test(lower) ? 'step' : /inventor|ipt|iam/i.test(lower) ? 'inventor' : /stl/i.test(lower) ? 'stl' : 'obj';
+    return { reply: `Opening ${format} import dialog...`, commands: [{ action: 'import', format }] };
+  }
 
-  const odMatch = text.match(/od\s*(\d+(?:\.\d+)?)|outer\s*(\d+(?:\.\d+)?)/i);
-  if (odMatch) {
-    outerDiameter = parseFloat(odMatch[1] || odMatch[2]);
-  } else if (numbers.length >= 1) {
-    outerDiameter = numbers[0];
+  // --- AI TOOLS ---
+  if (/\b(dfm|manufacturab|design\s*for\s*manuf)/i.test(lower)) {
+    return { reply: 'Running DFM analysis...', commands: [{ action: 'openPanel', panel: 'dfm' }] };
+  }
+  if (/\b(copilot|ai\s*assist|suggest)\b/i.test(lower)) {
+    return { reply: 'Opening AI Copilot.', commands: [{ action: 'openPanel', panel: 'copilot' }] };
+  }
+  if (/\b(reverse\s*engineer)/i.test(lower)) {
+    return { reply: 'Opening reverse engineering tool.', commands: [{ action: 'openPanel', panel: 'reverseEngineer' }] };
+  }
+  if (/\b(material\s*library|materials?\s*selector)\b/i.test(lower)) {
+    return { reply: 'Opening material library.', commands: [{ action: 'openPanel', panel: 'materials' }] };
+  }
+  if (/\b(generative\s*design)\b/i.test(lower)) {
+    return { reply: 'Opening generative design tool.', commands: [{ action: 'openPanel', panel: 'generative' }] };
   }
 
-  const idMatch = text.match(/id\s*(\d+(?:\.\d+)?)|inner\s*(\d+(?:\.\d+)?)/i);
-  if (idMatch) {
-    innerDiameter = parseFloat(idMatch[1] || idMatch[2]);
-  } else if (numbers.length >= 2) {
-    innerDiameter = numbers[1];
+  // --- CAM ---
+  if (/\b(cam|toolpath|cnc|machining)\b/i.test(lower)) {
+    return { reply: 'Opening CAM pipeline.', commands: [{ action: 'openPanel', panel: 'cam' }] };
+  }
+  if (/\b(g-?code|gcode)\b/i.test(lower)) {
+    return { reply: 'Opening G-code viewer.', commands: [{ action: 'openPanel', panel: 'gcode' }] };
   }
 
-  const hMatch = text.match(/height\s*(\d+(?:\.\d+)?)|thick\s*(\d+(?:\.\d+)?)/i);
-  if (hMatch) {
-    height = parseFloat(hMatch[1] || hMatch[2]);
-  } else if (numbers.length >= 3) {
-    height = numbers[2];
+  // --- COLLABORATION ---
+  if (/\b(collab|share|collaboration)\b/i.test(lower)) {
+    return { reply: 'Opening collaboration panel.', commands: [{ action: 'openPanel', panel: 'collab' }] };
+  }
+  if (/\b(vr|virtual\s*reality|immersive)\b/i.test(lower)) {
+    return { reply: 'Opening VR mode.', commands: [{ action: 'openPanel', panel: 'vr' }] };
   }
 
-  if (!outerDiameter || !innerDiameter) {
-    return null;
+  // --- ASSEMBLY ---
+  if (/^(assembly|assembly mode)\s*$/i.test(lower)) {
+    return { reply: 'Switching to assembly mode.', commands: [{ action: 'assemblyMode' }] };
+  }
+  if (/\b(explode|exploded\s*view)\b/i.test(lower)) {
+    return { reply: 'Toggling exploded view.', commands: [{ action: 'explode' }] };
   }
 
-  return {
-    type: 'spacer',
-    outerDiameter: Math.round(outerDiameter * 10) / 10,
-    innerDiameter: Math.round(innerDiameter * 10) / 10,
-    height: height ? Math.round(height * 10) / 10 : 5,
-  };
-}
+  // --- MEASURE ---
+  if (/\b(measure|distance|dimension|ruler)\b/i.test(lower)) {
+    return { reply: 'Measure tool active. Click two points to measure distance.', commands: [{ action: 'measure' }] };
+  }
 
-/**
- * Parse gear command
- */
-function parseGearCommand(text, numbers) {
-  let diameter, toothCount, thickness;
+  // --- SECTION VIEW ---
+  if (/\b(section|cross\s*section|section\s*cut|slice)\b/i.test(lower)) {
+    return { reply: 'Section cut tool active.', commands: [{ action: 'section' }] };
+  }
 
-  const diamMatch = text.match(/diameter\s*(\d+(?:\.\d+)?)|dia\s*(\d+(?:\.\d+)?)/i);
-  if (diamMatch) {
-    diameter = parseFloat(diamMatch[1] || diamMatch[2]);
-  } else if (numbers.length >= 1) {
-    diameter = numbers[0];
+  // --- SCREENSHOT ---
+  if (/\b(screenshot|capture|snapshot|save\s*image)\b/i.test(lower)) {
+    return { reply: 'Capturing screenshot...', commands: [{ action: 'screenshot' }] };
   }
 
-  const toothMatch = text.match(/(\d+)\s*teeth|tooth\s*(\d+)/i);
-  if (toothMatch) {
-    toothCount = parseInt(toothMatch[1] || toothMatch[2]);
-  } else if (numbers.length >= 2) {
-    toothCount = numbers[1];
+  // --- DXF EXPORT ---
+  if (/\b(dxf|engineering\s*drawing|2d\s*drawing)\b/i.test(lower)) {
+    return { reply: 'Exporting DXF engineering drawing...', commands: [{ action: 'export', format: 'dxf' }] };
   }
 
-  const thickMatch = text.match(/thick\s*(\d+(?:\.\d+)?)|height\s*(\d+(?:\.\d+)?)/i);
-  if (thickMatch) {
-    thickness = parseFloat(thickMatch[1] || thickMatch[2]);
-  } else if (numbers.length >= 3) {
-    thickness = numbers[2];
+  // --- SAVE / LOAD ---
+  if (/^save\s*(project|file|model)?\s*$/i.test(lower)) {
+    return { reply: 'Saving project...', commands: [{ action: 'save' }] };
+  }
+  if (/^(load|open)\s*(project|file|model)?\s*$/i.test(lower)) {
+    return { reply: 'Opening file picker...', commands: [{ action: 'load' }] };
   }
 
-  if (!diameter || !toothCount) {
-    return null;
+  // --- CONSTRAINT COMMANDS ---
+  if (/\b(constrain|constraint|lock|fix)\s*(horizontal|vertical|equal|parallel|perpendicular|tangent|coincident|concentric|symmetric)?\b/i.test(lower)) {
+    const type = (lower.match(/(horizontal|vertical|equal|parallel|perpendicular|tangent|coincident|concentric|symmetric)/)?.[1]) || 'fixed';
+    return { reply: `Adding ${type} constraint.`, commands: [{ action: 'addConstraint', type }] };
   }
 
-  return {
-    type: 'gear',
-    diameter: Math.round(diameter * 10) / 10,
-    teeth: toothCount,
-    thickness: thickness ? Math.round(thickness * 10) / 10 : 10,
-  };
+  return null; // not a scene action
 }
 
 // ============================================================================
-// OPERATION PARSERS
+// BOOLEAN OPERATION HANDLER
 // ============================================================================
 
-/**
- * Parse operations (holes, fillets, chamfers, etc.)
- */
-function parseOperations(text, numbers, commands) {
-  // Fillet
-  if (text.match(/fillet|round\s*edge|rounded/i)) {
-    const match = text.match(/(\d+(?:\.\d+)?)\s*mm\s*fillet|fillet\s*(\d+(?:\.\d+)?)/i);
-    const radius = match
-      ? parseFloat(match[1] || match[2])
-      : (numbers.length > 0 ? numbers[numbers.length - 1] : 2);
-
-    commands.push({
-      type: 'fillet',
-      radius: Math.round(radius * 10) / 10,
-    });
-  }
-
-  // Chamfer
-  if (text.match(/chamfer|beveled|bevel/i)) {
-    const match = text.match(/(\d+(?:\.\d+)?)\s*mm\s*chamfer|chamfer\s*(\d+(?:\.\d+)?)/i);
-    const distance = match
-      ? parseFloat(match[1] || match[2])
-      : (numbers.length > 0 ? numbers[numbers.length - 1] : 1);
-
-    commands.push({
-      type: 'chamfer',
-      distance: Math.round(distance * 10) / 10,
-    });
-  }
-
-  // Extrude
-  if (text.match(/extrude|extend|pull|raise/i)) {
-    const match = text.match(/extrude\s*(\d+(?:\.\d+)?)|(\d+(?:\.\d+)?)\s*mm\s*extrude/i);
-    const height = match
-      ? parseFloat(match[1] || match[2])
-      : (numbers.length > 0 ? numbers[numbers.length - 1] : 10);
-
-    commands.push({
-      type: 'extrude',
-      height: Math.round(height * 10) / 10,
-    });
-  }
-
-  // Revolve
-  if (text.match(/revolve|rotate|sweep|spin/i)) {
-    const match = text.match(/(\d+(?:\.\d+)?)\s*degree|revolve\s*(\d+)/i);
-    const angle = match
-      ? parseFloat(match[1] || match[2])
-      : 360;
-
-    commands.push({
-      type: 'revolve',
-      angle: Math.round(angle * 10) / 10,
-    });
+function detectBooleanOp(text) {
+  // Exact keyword match
+  if (/\b(subtract|substract|cut\s+from|difference|minus)\b/i.test(text)) return 'booleanSubtract';
+  if (/\b(intersect|intersection|overlap)\b/i.test(text)) return 'booleanIntersect';
+  if (/\b(union|combine|merge|join|fuse)\b/i.test(text)) return 'booleanUnion';
+
+  // Fuzzy match for typos like "interset", "subtrat", "intersec"
+  const boolKeywords = {
+    booleanIntersect: ['intersect', 'intersection', 'overlap'],
+    booleanSubtract: ['subtract', 'substract', 'difference'],
+    booleanUnion: ['union', 'combine', 'merge', 'join', 'fuse'],
+  };
+  const words = text.replace(/[^a-z\s]/g, '').split(/\s+/).filter(w => w.length >= 4);
+  for (const w of words) {
+    for (const [op, keywords] of Object.entries(boolKeywords)) {
+      for (const kw of keywords) {
+        if (levenshtein(w, kw) <= 2) return op;
+      }
+    }
   }
+  return null;
 }
 
-/**
- * Parse hole patterns (through holes, corner holes, bolt circles)
- */
-function parseHolePattern(text) {
-  const pattern = {};
+function handleBoolean(booleanOp, lower, features, selectedIdx) {
+  const opName = booleanOp.replace('boolean', '').toLowerCase();
 
-  // Through hole
-  const throughMatch = text.match(/(\d+(?:\.\d+)?)\s*mm\s*hole\s*through|hole\s*through\s*(?:center)?/i);
-  if (throughMatch) {
-    const diameter = parseFloat(throughMatch[1]) || 10;
+  // 1. Check for inline shape with dimensions: "intersect with a box 20mm"
+  const inlineShape = tryParseInlineShape(lower);
+  if (inlineShape && features.length >= 1) {
+    const targetIdx = selectedIdx >= 0 ? selectedIdx : features.length - 1;
     return {
-      type: 'through',
-      diameter,
-      centerX: 0,
-      centerY: 0,
+      reply: `Creating ${generateDescription(inlineShape)}, then ${opName}ing with "${features[targetIdx]?.name || 'Part'}".`,
+      commands: [inlineShape, { action: booleanOp, toolIndex: -1, targetIndex: targetIdx }]
     };
   }
 
-  // Corner holes
-  const cornerMatch = text.match(/(\d+)\s*holes?(?:\s+at)?\s*corners?/i);
-  if (cornerMatch) {
-    const count = parseInt(cornerMatch[1]);
-    const diamMatch = text.match(/(\d+(?:\.\d+)?)\s*mm\s*(?:diameter|dia)/i);
-    const diameter = diamMatch ? parseFloat(diamMatch[1]) : 8;
-
+  // 2. Check for "intersect with box" / "intersect box and cylinder" — referring to existing parts
+  // Try to resolve named parts from the text
+  const { tool, target } = resolveBooleanPair(lower, features);
+  if (tool >= 0 && target >= 0 && tool !== target) {
     return {
-      type: 'corners',
-      count,
-      diameter,
+      reply: `${opName.charAt(0).toUpperCase() + opName.slice(1)}ed "${features[tool]?.name || 'Part A'}" with "${features[target]?.name || 'Part B'}".`,
+      commands: [{ action: booleanOp, toolIndex: tool, targetIndex: target }]
     };
   }
 
-  // Bolt circle
-  const boltMatch = text.match(/(\d+)\s*bolt\s*(?:hole)?s?|bolt\s*circle\s*(\d+)/i);
-  if (boltMatch) {
-    const count = parseInt(boltMatch[1] || boltMatch[2]);
-    const diamMatch = text.match(/(\d+(?:\.\d+)?)\s*mm\s*(?:diameter|dia|bolt)/i);
-    const diameter = diamMatch ? parseFloat(diamMatch[1]) : 8;
-    const circleMatch = text.match(/circle\s*(\d+(?:\.\d+)?)/i);
-    const circleDia = circleMatch ? parseFloat(circleMatch[1]) : 60;
+  // 3. "intersect with [partname]" — one part named, use selected/last as the other
+  const withMatch = lower.match(/(?:with|and)\s+(?:the\s+)?(\w+)/);
+  if (withMatch && features.length >= 2) {
+    const namedIdx = findFeatureByKeyword(withMatch[1], features);
+    if (namedIdx >= 0) {
+      const otherIdx = selectedIdx >= 0 && selectedIdx !== namedIdx ? selectedIdx :
+        (features.length - 1 !== namedIdx ? features.length - 1 : features.length - 2);
+      if (otherIdx >= 0 && otherIdx !== namedIdx) {
+        return {
+          reply: `${opName.charAt(0).toUpperCase() + opName.slice(1)}ed "${features[otherIdx]?.name || 'Part A'}" with "${features[namedIdx]?.name || 'Part B'}".`,
+          commands: [{ action: booleanOp, toolIndex: namedIdx, targetIndex: otherIdx }]
+        };
+      }
+    }
+  }
 
+  // 4. Just "intersect" with 2+ parts — use last two
+  if (features.length >= 2) {
+    const t = features.length - 1;
+    const s = features.length - 2;
     return {
-      type: 'boltcircle',
-      count,
-      diameter,
-      circleDiameter: circleDia,
+      reply: `${opName.charAt(0).toUpperCase() + opName.slice(1)}ed "${features[s]?.name || 'Part A'}" with "${features[t]?.name || 'Part B'}".`,
+      commands: [{ action: booleanOp, toolIndex: t, targetIndex: s }]
     };
   }
 
-  return null;
+  return { reply: `Need at least 2 parts for ${opName}. Create a second part first, or say "${opName} with a box 20mm".`, commands: [] };
 }
 
 // ============================================================================
-// UTILITY PARSERS
+// TARGET RESOLUTION (which part does the user mean?)
 // ============================================================================
 
-/**
- * Parse all numbers from text with unit conversion
- * @returns {Array<number>} Array of converted numbers (in mm)
- */
-export function parseNumbers(text) {
-  const numbers = [];
-  const numberRegex = /(\d+(?:\.\d+)?)\s*(mm|cm|m|in|inch|ft|foot)?/gi;
-  let match;
+function resolveTarget(text, features, selectedIdx) {
+  if (!features || features.length === 0) return -1;
 
-  while ((match = numberRegex.exec(text)) !== null) {
-    const value = parseFloat(match[1]);
-    const unit = (match[2] || 'mm').toLowerCase();
-    const factor = UNIT_FACTORS[unit] || 1;
-    numbers.push(value * factor);
-  }
+  // "the selected" / "current" / "this"
+  if (/\b(selected|current|this)\b/.test(text) && selectedIdx >= 0) return selectedIdx;
 
-  return numbers;
-}
+  // "the last" / "last one" / "it"
+  if (/\b(last|it|that)\b/.test(text)) return features.length - 1;
 
-/**
- * Parse dimension patterns like "100x60x20" or "100 by 60 by 20"
- * @returns {Array<number>} Array of dimensions
- */
-export function parseDimensions(text) {
-  const dimensions = [];
+  // "the first" / "first one"
+  if (/\b(first)\b/.test(text)) return 0;
 
-  // Try X pattern: "100x60x20"
-  const xMatch = text.match(/(\d+(?:\.\d+)?)\s*x\s*(\d+(?:\.\d+)?)\s*(?:x\s*(\d+(?:\.\d+)?))?/i);
-  if (xMatch) {
-    dimensions.push(parseFloat(xMatch[1]));
-    dimensions.push(parseFloat(xMatch[2]));
-    if (xMatch[3]) {
-      dimensions.push(parseFloat(xMatch[3]));
+  // "the second" / "third" etc
+  const ordinals = { second: 1, third: 2, fourth: 3, fifth: 4, sixth: 5 };
+  for (const [word, idx] of Object.entries(ordinals)) {
+    if (text.includes(word) && idx < features.length) return idx;
+  }
+
+  // "the box" / "the cylinder" / part by type name
+  for (let i = features.length - 1; i >= 0; i--) {
+    const name = (features[i].name || '').toLowerCase();
+    const type = (features[i].type || '').toLowerCase();
+    // Check each part type synonym
+    for (const [pType, synonyms] of Object.entries(PART_TYPE_SYNONYMS)) {
+      for (const syn of synonyms) {
+        if (text.includes(syn) && (name.includes(syn) || name.includes(pType) || type === pType)) {
+          return i;
+        }
+      }
     }
-    return dimensions;
   }
 
-  // Try "by" pattern: "100 by 60 by 20"
-  const byMatch = text.match(/(\d+(?:\.\d+)?)\s+by\s+(\d+(?:\.\d+)?)\s+(?:by\s+(\d+(?:\.\d+)?))?/i);
-  if (byMatch) {
-    dimensions.push(parseFloat(byMatch[1]));
-    dimensions.push(parseFloat(byMatch[2]));
-    if (byMatch[3]) {
-      dimensions.push(parseFloat(byMatch[3]));
+  // "the square" → box
+  if (/\bsquare\b/.test(text)) {
+    for (let i = features.length - 1; i >= 0; i--) {
+      const name = (features[i].name || '').toLowerCase();
+      const type = (features[i].type || '').toLowerCase();
+      if (type === 'box' || name.includes('box') || name.includes('cube') || name.includes('square')) return i;
     }
-    return dimensions;
   }
 
-  return dimensions;
+  // By name substring
+  const nameMatch = text.match(/(?:the|named?)\s+["']?(\w+)["']?/);
+  if (nameMatch) {
+    const search = nameMatch[1].toLowerCase();
+    for (let i = features.length - 1; i >= 0; i--) {
+      if ((features[i].name || '').toLowerCase().includes(search)) return i;
+    }
+  }
+
+  return -1;
 }
 
-/**
- * Detect primary part type from text
- * @returns {string} Part type identifier
- */
-export function detectPartType(text) {
-  text = text.toLowerCase();
+function resolveBooleanPair(text, features) {
+  // Try "subtract A from B" pattern
+  const fromMatch = text.match(/(?:subtract|cut|intersect)\s+(?:the\s+)?(\w+)\s+from\s+(?:the\s+)?(\w+)/i);
+  if (fromMatch) {
+    const toolIdx = findFeatureByKeyword(fromMatch[1], features);
+    const targetIdx = findFeatureByKeyword(fromMatch[2], features);
+    if (toolIdx >= 0 && targetIdx >= 0) return { tool: toolIdx, target: targetIdx };
+  }
 
-  for (const [type, synonyms] of Object.entries(PART_TYPE_SYNONYMS)) {
-    for (const synonym of synonyms) {
-      if (text.includes(synonym)) {
-        return type;
-      }
-    }
+  // Try "intersect A and B" / "intersect A with B"
+  const andMatch = text.match(/(?:intersect|union|combine|merge)\s+(?:the\s+)?(\w+)\s+(?:and|with)\s+(?:the\s+)?(\w+)/i);
+  if (andMatch) {
+    const a = findFeatureByKeyword(andMatch[1], features);
+    const b = findFeatureByKeyword(andMatch[2], features);
+    if (a >= 0 && b >= 0) return { tool: a, target: b };
   }
 
-  return 'box'; // default
+  // Default: last two parts
+  return { tool: features.length - 1, target: features.length - 2 };
+}
+
+function findFeatureByKeyword(keyword, features) {
+  const kw = keyword.toLowerCase();
+  // "square" → box
+  const typeMap = { square: 'box', cube: 'box', block: 'box', rod: 'cylinder', shaft: 'cylinder', ball: 'sphere', ring: 'torus', donut: 'torus' };
+  const mapped = typeMap[kw] || kw;
+
+  for (let i = features.length - 1; i >= 0; i--) {
+    const name = (features[i].name || '').toLowerCase();
+    const type = (features[i].type || '').toLowerCase();
+    if (name.includes(mapped) || type.includes(mapped) || name.includes(kw)) return i;
+  }
+  return -1;
 }
 
 // ============================================================================
-// DESCRIPTION GENERATION
+// INLINE SHAPE PARSER (for "intersect with a box 20mm")
 // ============================================================================
 
-/**
- * Convert CAD command back to human-readable description
- */
-export function generateDescription(command) {
-  switch (command.type) {
-    case 'box':
-      return `${command.width}x${command.height}x${command.depth}mm box`;
-    case 'cylinder':
-      return `cylinder r${command.radius}mm h${command.height}mm`;
-    case 'sphere':
-      return `sphere r${command.radius}mm`;
-    case 'cone':
-      return `cone r${command.radius}mm h${command.height}mm`;
-    case 'bracket':
-      return `${command.width}x${command.height}x${command.thickness}mm bracket`;
-    case 'flange':
-      return `flange OD${command.outerDiameter}mm ID${command.innerDiameter}mm h${command.height}mm`;
-    case 'washer':
-      return `washer OD${command.outerDiameter}mm ID${command.innerDiameter}mm`;
-    case 'spacer':
-      return `spacer OD${command.outerDiameter}mm ID${command.innerDiameter}mm h${command.height}mm`;
-    case 'gear':
-      return `${command.teeth}-tooth gear d${command.diameter}mm`;
-    case 'fillet':
-      return `fillet r${command.radius}mm`;
-    case 'chamfer':
-      return `chamfer ${command.distance}mm`;
-    case 'extrude':
-      return `extrude ${command.height}mm`;
-    case 'revolve':
-      return `revolve ${command.angle}°`;
-    case 'cut':
-      return `cut ${command.shape} hole`;
-    default:
-      return JSON.stringify(command);
-  }
+function tryParseInlineShape(text) {
+  // Strip the boolean keyword and prepositions to find shape description
+  const cleaned = text
+    .replace(/\b(intersect|subtract|cut|union|combine|merge|join|fuse|difference|minus|overlap)\b/gi, '')
+    .replace(/\b(it|this|that|the|from|with|and|a|an|of)\b/gi, '')
+    .trim();
+
+  if (!cleaned) return null;
+
+  const partType = detectPartType(cleaned);
+  if (!partType) return null;
+
+  // Only create inline shape if dimensions are specified
+  // "intersect cube and cylinder" should NOT create new shapes — it refers to existing parts
+  const numbers = parseNumbers(cleaned);
+  const dims = parseDimensions(cleaned);
+  if (numbers.length === 0 && dims.length === 0) return null; // no dimensions = refers to existing part
+
+  return parseByType(partType, cleaned, numbers, dims);
 }
 
 // ============================================================================
-// API KEY MANAGEMENT
+// DIRECTION PARSING
 // ============================================================================
 
-/**
- * Set LLM API keys for enhanced parsing
- */
-export function setAPIKeys(geminiKey, groqKey) {
-  chatState.apiKeys.gemini = geminiKey || null;
-  chatState.apiKeys.groq = groqKey || null;
+function parseDirection(text) {
+  if (/\b(up|above|higher)\b/.test(text)) return { axis: 'y', sign: 1, label: 'up' };
+  if (/\b(down|below|lower)\b/.test(text)) return { axis: 'y', sign: -1, label: 'down' };
+  if (/\b(left)\b/.test(text)) return { axis: 'x', sign: -1, label: 'left' };
+  if (/\b(right)\b/.test(text)) return { axis: 'x', sign: 1, label: 'right' };
+  if (/\b(forward|front)\b/.test(text)) return { axis: 'z', sign: 1, label: 'forward' };
+  if (/\b(back|backward|behind)\b/.test(text)) return { axis: 'z', sign: -1, label: 'back' };
+  if (/\b(away|outside|out|apart)\b/.test(text)) return { axis: 'x', sign: 1, label: 'away' };
+  return { axis: 'y', sign: 1, label: 'up' }; // default
+}
 
-  localStorage.setItem('cyclecad_api_keys', JSON.stringify(chatState.apiKeys));
+function parseFirstNumber(text) {
+  const m = text.match(/(\d+(?:\.\d+)?)/);
+  return m ? parseFloat(m[1]) : 0;
 }
 
-/**
- * Get current API keys
- */
-export function getAPIKeys() {
-  return { ...chatState.apiKeys };
+// ============================================================================
+// CONVERSATIONAL HANDLER (no LLM needed)
+// ============================================================================
+
+function handleConversational(lower, original) {
+  // Greetings
+  if (/^(hi|hello|hey|sup|yo|good morning|good evening|what's up)[\s!.?]*$/i.test(lower)) {
+    return 'Hey! Ready to design something. What would you like to create?';
+  }
+
+  // Help / what can you do
+  if (/what can you (do|make|create|build)|help me|help$|what.*shapes|what.*types|capabilities/i.test(lower)) {
+    return `I can help you design in 3D!\n\n**Create shapes:** box, cylinder, sphere, cone, torus, bracket, plate, flange, washer, spacer, gear\n\n**Modify parts:** "remove it", "delete the box", "undo", "redo"\n**Transform:** "move it up 20", "rotate 45°", "scale 2x", "make it bigger"\n**Booleans:** "subtract box from cylinder", "intersect", "union"\n**Scene:** "hide it", "show all", "select the cylinder", "clear scene"\n**View:** "wireframe", "grid", "fit all", "export stl"\n\n**Examples:**\n• "cylinder 30mm diameter 80mm tall"\n• "bracket 80x40x5"\n• "gear 60mm diameter 24 teeth"\n• "move it left 50"\n• "delete the box"\n\nJust describe what you want!`;
+  }
+
+  // Thanks
+  if (/^(thanks|thank you|thx|cheers|nice|cool|great|awesome|perfect)[\s!.]*$/i.test(lower)) {
+    return 'You\'re welcome! What\'s next?';
+  }
+
+  // Clear / reset
+  if (/^(clear|reset|start over|new|clean)[\s!.]*$/i.test(lower)) {
+    return 'Ready for a fresh start. What would you like to create?';
+  }
+
+  // How to use
+  if (/how (do i|to|does)|tutorial|getting started|explain/i.test(lower)) {
+    return `**Quick start:**\n1. Type a shape: "cylinder 40mm diameter 100 tall"\n2. I\'ll create it in the 3D viewport\n3. Modify: "fillet 5mm", "move it up 20", "make it bigger"\n4. Combine: "subtract box from cylinder"\n5. Clean up: "remove it", "undo"\n\nPress **?** for the full help panel.`;
+  }
+
+  // What did you make / last part / what's in scene
+  if (/what('s| is)?\s+(in|on)\s+(the\s+)?(scene|viewport|view)|what did you (make|create|build)|list\s*parts|scene\s*info|inventory/i.test(lower)) {
+    const scene = getSceneContext();
+    if (scene.length === 0) return 'The scene is empty. Try creating something: "box 50mm"';
+    return `**Parts in scene (${scene.length}):**\n${scene.map((p, i) => `${i + 1}. ${p}`).join('\n')}`;
+  }
+
+  // API key setting
+  if (/set.*key|api.*key|gemini.*key|groq.*key/i.test(lower)) {
+    const geminiMatch = original.match(/gemini[:\s]+([A-Za-z0-9_-]{20,})/i);
+    const groqMatch = original.match(/groq[:\s]+([A-Za-z0-9_-]{20,})/i);
+    if (geminiMatch || groqMatch) {
+      setAPIKeys(geminiMatch?.[1] || chatState.apiKeys.gemini, groqMatch?.[1] || chatState.apiKeys.groq);
+      return 'API key saved! I\'ll use AI for smarter responses now.';
+    }
+    return `To enable AI mode, set your API key:\n\n**Gemini (free):** "set gemini key AIza..."\n**Groq (free):** "set groq key gsk_..."\n\nGet a free Gemini key at: aistudio.google.com/apikey`;
+  }
+
+  return null; // not conversational
 }
 
 // ============================================================================
-// LLM INTEGRATION
+// SCENE CONTEXT
 // ============================================================================
 
-/**
- * Query LLM for complex CAD parsing
- * Falls back to local parser on failure
- */
-async function queryLLM(prompt) {
-  const systemPrompt = `You are a CAD command parser. Convert natural language descriptions into JSON CAD commands.
+function getSceneContext() {
+  const parts = [];
+  try {
+    const features = window.APP?.features || [];
+    features.forEach(f => {
+      const p = f.params || {};
+      let desc = f.name || f.type || 'Part';
+      if (p.width && p.height) desc += ` (${p.width}×${p.height}${p.depth ? '×' + p.depth : ''}mm)`;
+      else if (p.radius) desc += ` (r${p.radius}mm${p.height ? ' h' + p.height + 'mm' : ''})`;
+      parts.push(desc);
+    });
+  } catch (e) {}
+  return parts;
+}
+
+// ============================================================================
+// SMART LLM INTEGRATION
+// ============================================================================
 
-Return a JSON array of command objects. Each command has:
-- type: 'box', 'cylinder', 'sphere', 'cone', 'bracket', 'flange', 'gear', 'washer', 'spacer', 'fillet', 'chamfer', 'extrude', 'revolve', 'cut'
-- Relevant dimensions (width, height, depth, radius, diameter, teeth, etc.)
+const CAD_SYSTEM_PROMPT = `You are a CAD assistant for cycleCAD, a browser-based 3D modeler. You help users create and modify 3D parts.
 
-Examples:
-"50mm cube" → [{"type":"box","width":50,"height":50,"depth":50}]
-"cylinder r30 h60" → [{"type":"cylinder","radius":30,"height":60}]
-"100x60x20 box with 10mm fillet" → [{"type":"box","width":100,"height":60,"depth":20},{"type":"fillet","radius":10}]
+RESPONSE FORMAT: Always respond with valid JSON:
+{
+  "reply": "Your conversational response to the user",
+  "commands": [array of command objects, or empty array if just chatting]
+}
 
-Return ONLY valid JSON, no other text.`;
+AVAILABLE COMMANDS:
+
+Create shapes:
+- {"type":"box","width":N,"height":N,"depth":N}
+- {"type":"cylinder","radius":N,"height":N}
+- {"type":"sphere","radius":N}
+- {"type":"cone","radius":N,"height":N}
+- {"type":"torus","radius":N,"tube":N}
+- {"type":"bracket","width":N,"height":N,"thickness":N}
+- {"type":"plate","width":N,"height":N,"thickness":N}
+- {"type":"flange","outerDiameter":N,"innerDiameter":N,"height":N}
+- {"type":"washer","outerDiameter":N,"innerDiameter":N,"thickness":N}
+- {"type":"spacer","outerDiameter":N,"innerDiameter":N,"height":N}
+- {"type":"gear","diameter":N,"teeth":N,"thickness":N}
+
+Operations on existing parts:
+- {"type":"fillet","radius":N}
+- {"type":"chamfer","distance":N}
+
+Scene actions:
+- {"action":"delete","index":N} — delete part at index (0-based), or -1 for last
+- {"action":"undo"}
+- {"action":"redo"}
+- {"action":"clearScene"}
+- {"action":"hide","index":N}
+- {"action":"showAll"}
+- {"action":"select","index":N}
+- {"action":"move","index":N,"axis":"x|y|z","distance":N} — negative for opposite direction
+- {"action":"rotate","index":N,"axis":"x|y|z","angle":N}
+- {"action":"scale","index":N,"factor":N}
+- {"action":"duplicate","index":N}
+- {"action":"color","index":N,"color":"red|blue|green|..."}
+- {"action":"rename","index":N,"name":"New Name"}
+- {"action":"booleanSubtract","toolIndex":N,"targetIndex":N}
+- {"action":"booleanIntersect","toolIndex":N,"targetIndex":N}
+- {"action":"booleanUnion","toolIndex":N,"targetIndex":N}
+- {"action":"fitAll"}
+- {"action":"wireframe"}
+- {"action":"grid"}
+- {"action":"export","format":"stl|obj|gltf"}
+
+RULES:
+1. All dimensions in mm. Convert from other units if needed.
+2. "diameter X" → radius = X/2 for cylinders/spheres.
+3. For multi-step: "box with hole and fillet" → create multiple commands.
+4. For questions/chat, set commands to [] and put answer in reply.
+5. Be concise (1-2 sentences for creation, more for explanations).
+6. Use -1 for index to mean "last/most recent part".
+7. "it" / "that" / "the last one" = the most recently created part.
+8. "the box" / "the cylinder" = find by type name in scene.
+9. "remove it" / "delete it" → {"action":"delete","index":-1}
+10. "move it up 20" → {"action":"move","index":-1,"axis":"y","distance":20}
+11. "make it bigger" → {"action":"scale","index":-1,"factor":1.5}
+
+SCENE CONTEXT will be appended to user messages showing what parts exist.`;
+
+async function querySmartLLM(userText) {
+  const recentHistory = chatState.conversationHistory.slice(-10);
+  const sceneCtx = getSceneContext();
+
+  let contextNote = '';
+  if (sceneCtx.length > 0) {
+    contextNote = `\n[Scene has ${sceneCtx.length} parts: ${sceneCtx.map((p, i) => `[${i}] ${p}`).join(', ')}]`;
+  } else {
+    contextNote = '\n[Scene is empty]';
+  }
 
   try {
-    // Try Gemini Flash first
     if (chatState.apiKeys.gemini) {
-      return await queryGemini(prompt, systemPrompt);
+      return await queryGeminiSmart(userText, recentHistory, contextNote);
     }
-
-    // Try Groq Llama
     if (chatState.apiKeys.groq) {
-      return await queryGroq(prompt, systemPrompt);
+      return await queryGroqSmart(userText, recentHistory, contextNote);
     }
-  } catch (error) {
-    console.warn('LLM query failed:', error);
-    throw error;
+  } catch (e) {
+    console.warn('Smart LLM query failed:', e);
+    throw e;
   }
 }
 
-/**
- * Query Google Gemini Flash API
- */
-async function queryGemini(prompt, systemPrompt) {
-  const response = await fetch('https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=' + chatState.apiKeys.gemini, {
+async function queryGeminiSmart(userText, history, contextNote) {
+  const contents = [];
+  for (const msg of history.slice(0, -1)) {
+    contents.push({
+      role: msg.role === 'model' ? 'model' : 'user',
+      parts: [{ text: msg.text }]
+    });
+  }
+  contents.push({ role: 'user', parts: [{ text: userText + contextNote }] });
+
+  const model = 'gemini-2.0-flash';
+  const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${chatState.apiKeys.gemini}`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({
-      system_instruction: { parts: [{ text: systemPrompt }] },
-      contents: [{ parts: [{ text: prompt }] }],
+      system_instruction: { parts: [{ text: CAD_SYSTEM_PROMPT }] },
+      contents,
+      generationConfig: {
+        temperature: 0.3,
+        responseMimeType: 'application/json',
+      }
     }),
   });
 
   if (!response.ok) {
-    throw new Error(`Gemini API error: ${response.statusText}`);
+    const err = await response.text().catch(() => response.statusText);
+    throw new Error(`Gemini error: ${err}`);
   }
 
   const data = await response.json();
   const text = data.candidates?.[0]?.content?.parts?.[0]?.text || '';
-  return JSON.parse(text);
+  return parseLLMResponse(text);
 }
 
-/**
- * Query Groq Llama 3.1 API
- */
-async function queryGroq(prompt, systemPrompt) {
+async function queryGroqSmart(userText, history, contextNote) {
+  const messages = [{ role: 'system', content: CAD_SYSTEM_PROMPT }];
+  for (const msg of history.slice(0, -1)) {
+    messages.push({
+      role: msg.role === 'model' ? 'assistant' : 'user',
+      content: msg.text
+    });
+  }
+  messages.push({ role: 'user', content: userText + contextNote });
+
   const response = await fetch('https://api.groq.com/openai/v1/chat/completions', {
     method: 'POST',
     headers: {
@@ -958,27 +1130,439 @@ async function queryGroq(prompt, systemPrompt) {
     },
     body: JSON.stringify({
       model: 'llama-3.1-8b-instant',
-      messages: [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: prompt },
-      ],
-      temperature: 0,
+      messages,
+      temperature: 0.3,
+      response_format: { type: 'json_object' },
     }),
   });
 
-  if (!response.ok) {
-    throw new Error(`Groq API error: ${response.statusText}`);
-  }
+  if (!response.ok) throw new Error(`Groq error: ${response.statusText}`);
 
   const data = await response.json();
   const text = data.choices?.[0]?.message?.content || '';
-  return JSON.parse(text);
+  return parseLLMResponse(text);
+}
+
+function parseLLMResponse(text) {
+  try {
+    let clean = text.trim();
+    if (clean.startsWith('```json')) clean = clean.slice(7);
+    if (clean.startsWith('```')) clean = clean.slice(3);
+    if (clean.endsWith('```')) clean = clean.slice(0, -3);
+    clean = clean.trim();
+
+    const parsed = JSON.parse(clean);
+
+    if (parsed.reply && Array.isArray(parsed.commands)) {
+      return { reply: parsed.reply, commands: parsed.commands };
+    }
+
+    if (Array.isArray(parsed)) {
+      const desc = parsed.map(c => generateDescription(c)).join(', ');
+      return { reply: `Creating: ${desc}`, commands: parsed };
+    }
+  } catch (e) {
+    console.warn('Failed to parse LLM response:', text, e);
+  }
+  return null;
 }
 
 // ============================================================================
-// EXPORTS
+// SMART LOCAL PARSING (creation commands fallback)
 // ============================================================================
 
+function localParseCADPrompt(text) {
+  const commands = [];
+
+  // Strip "create/make/draw/build/generate" prefix for cleaner parsing
+  const cleaned = text.replace(/^(create|make|draw|build|generate|add|design|model|give me|i want|i need)\s+(a\s+|an\s+|me\s+a\s+|me\s+an\s+)?/i, '');
+
+  // FIRST: try parsing the FULL sentence (handles "cylinder with 30mm diameter and 45mm height")
+  const fullType = detectPartType(cleaned);
+  if (fullType) {
+    const allNumbers = parseNumbers(cleaned);
+    const allDims = parseDimensions(cleaned);
+    const cmd = parseByType(fullType, cleaned, allNumbers, allDims);
+    if (cmd) {
+      commands.push(cmd);
+      // Also check for trailing operations like "with 5mm fillet"
+      parseOperations(cleaned, allNumbers, commands);
+      return commands;
+    }
+  }
+
+  // FALLBACK: Split on "and" / "with" / "then" for multi-step
+  const parts = cleaned.split(/\s+(?:and|with|then|plus|\+)\s+/);
+
+  for (const part of parts) {
+    const partType = detectPartType(part);
+    const numbers = parseNumbers(part);
+    const dims = parseDimensions(part);
+
+    const cmd = partType ? parseByType(partType, part, numbers, dims) : null;
+
+    if (cmd) {
+      commands.push(cmd);
+    } else {
+      // Try as operation (fillet, chamfer, extrude, revolve, hole)
+      parseOperations(part, numbers, commands);
+    }
+  }
+
+  return commands;
+}
+
+function parseByType(partType, text, numbers, dims) {
+  switch (partType) {
+    case 'cube':
+    case 'box': return parseBoxCommand(text, numbers, dims);
+    case 'cylinder': return parseCylinderCommand(text, numbers);
+    case 'sphere': return parseSphereCommand(text, numbers);
+    case 'cone': return parseConeCommand(text, numbers);
+    case 'torus': return parseTorusCommand(text, numbers);
+    case 'plate': return parsePlateCommand(text, numbers, dims);
+    case 'bracket': return parseBracketCommand(text, numbers, dims);
+    case 'flange': return parseFlangeCommand(text, numbers);
+    case 'washer': return parseWasherCommand(text, numbers);
+    case 'spacer': return parseSpacerCommand(text, numbers);
+    case 'gear': return parseGearCommand(text, numbers);
+    default: return null;
+  }
+}
+
+// ============================================================================
+// PRIMITIVE PARSERS
+// ============================================================================
+
+function parseBoxCommand(text, numbers, dims) {
+  let width, height, depth;
+
+  // Check for named dimensions: "width 50", "height 30", "depth 20"
+  const wMatch = text.match(/(?:width|wide|w)\s*(?:of\s*)?(\d+(?:\.\d+)?)/i);
+  const hMatch = text.match(/(?:height|tall|high|h)\s*(?:of\s*)?(\d+(?:\.\d+)?)/i);
+  const dMatch = text.match(/(?:depth|deep|long|length|d)\s*(?:of\s*)?(\d+(?:\.\d+)?)/i);
+
+  if (wMatch || hMatch || dMatch) {
+    width = wMatch ? parseFloat(wMatch[1]) : null;
+    height = hMatch ? parseFloat(hMatch[1]) : null;
+    depth = dMatch ? parseFloat(dMatch[1]) : null;
+    // Fill missing dims with first available or default
+    const known = width || height || depth || 20;
+    width = width || known;
+    height = height || known;
+    depth = depth || Math.min(width, height);
+  } else if (dims.length === 3) [width, height, depth] = dims;
+  else if (dims.length === 2) { width = dims[0]; height = dims[1]; depth = Math.min(dims[0], dims[1]); }
+  else if (dims.length === 1) width = height = depth = dims[0];
+  else if (numbers.length >= 3) { width = numbers[0]; height = numbers[1]; depth = numbers[2]; }
+  else if (numbers.length === 2) { width = numbers[0]; height = numbers[0]; depth = numbers[1]; }
+  else if (numbers.length === 1) width = height = depth = numbers[0];
+  else return null;
+  return { type: 'box', width: r(width), height: r(height), depth: r(depth) };
+}
+
+function parseCylinderCommand(text, numbers) {
+  let radius, height;
+  const diaMatch = text.match(/(?:diameter|dia)\s*(?:of\s*)?(\d+(?:\.\d+)?)/i);
+  if (diaMatch) radius = parseFloat(diaMatch[1]) / 2;
+  const rMatch = text.match(/(?:radius|rad)\s*(?:of\s*)?(\d+(?:\.\d+)?)/i);
+  if (rMatch) radius = parseFloat(rMatch[1]);
+  if (!radius) { const rm = text.match(/\br\s*(\d+(?:\.\d+)?)/i); if (rm) radius = parseFloat(rm[1]); }
+
+  const hMatch = text.match(/(?:height|tall|long|h)\s*(?:of\s*)?(\d+(?:\.\d+)?)/i);
+  if (hMatch) height = parseFloat(hMatch[1]);
+
+  if (!radius && !height && numbers.length >= 2) { radius = numbers[0]; height = numbers[1]; }
+  else if (!radius && numbers.length >= 1) { radius = numbers[0]; height = radius * 2; }
+  if (!height && radius) height = radius * 2;
+  if (!radius || !height) return null;
+  return { type: 'cylinder', radius: r(radius), height: r(height) };
+}
+
+function parseSphereCommand(text, numbers) {
+  let radius;
+  const diaMatch = text.match(/(?:diameter|dia)\s*(?:of\s*)?(\d+(?:\.\d+)?)/i);
+  if (diaMatch) radius = parseFloat(diaMatch[1]) / 2;
+  else if (numbers.length >= 1) radius = numbers[0];
+  if (!radius) return null;
+  return { type: 'sphere', radius: r(radius) };
+}
+
+function parseConeCommand(text, numbers) {
+  let radius, height;
+  if (numbers.length >= 2) { radius = numbers[0]; height = numbers[1]; }
+  else if (numbers.length === 1) { radius = numbers[0]; height = radius * 1.5; }
+  if (!radius) return null;
+  return { type: 'cone', radius: r(radius), height: r(height) };
+}
+
+function parseTorusCommand(text, numbers) {
+  let radius, tube;
+  if (numbers.length >= 2) { radius = numbers[0]; tube = numbers[1]; }
+  else if (numbers.length === 1) { radius = numbers[0]; tube = radius * 0.3; }
+  if (!radius) return null;
+  return { type: 'torus', radius: r(radius), tube: r(tube) };
+}
+
+function parsePlateCommand(text, numbers, dims) {
+  let width, depth, thickness;
+  if (dims.length >= 3) { width = dims[0]; depth = dims[1]; thickness = dims[2]; }
+  else if (dims.length === 2) { width = dims[0]; depth = dims[1]; thickness = 5; }
+  else if (numbers.length >= 2) { width = numbers[0]; depth = numbers[1]; thickness = numbers[2] || 5; }
+  if (!width || !depth) return null;
+  return { type: 'plate', width: r(width), height: r(depth), thickness: r(thickness) };
+}
+
+function parseBracketCommand(text, numbers, dims) {
+  let width, height, thickness;
+  if (dims.length >= 3) { width = dims[0]; height = dims[1]; thickness = dims[2]; }
+  else if (dims.length === 2) { width = dims[0]; height = dims[1]; thickness = 5; }
+  else if (numbers.length >= 2) { width = numbers[0]; height = numbers[1]; thickness = numbers[2] || 5; }
+  if (!width || !height) return null;
+  return { type: 'bracket', width: r(width), height: r(height), thickness: r(thickness) };
+}
+
+function parseFlangeCommand(text, numbers) {
+  let od, id, height;
+  const odMatch = text.match(/(?:od|outer\s*(?:diameter)?)\s*(\d+(?:\.\d+)?)/i);
+  if (odMatch) od = parseFloat(odMatch[1]);
+  const idMatch = text.match(/(?:id|inner\s*(?:diameter)?)\s*(\d+(?:\.\d+)?)/i);
+  if (idMatch) id = parseFloat(idMatch[1]);
+  const hMatch = text.match(/(?:h|height|thick)\s*(\d+(?:\.\d+)?)/i);
+  if (hMatch) height = parseFloat(hMatch[1]);
+  if (!od && numbers.length >= 1) od = numbers[0];
+  if (!id && numbers.length >= 2) id = numbers[1];
+  if (!height && numbers.length >= 3) height = numbers[2];
+  if (!od) return null;
+  return { type: 'flange', outerDiameter: r(od), innerDiameter: r(id || od * 0.4), height: r(height || 10) };
+}
+
+function parseWasherCommand(text, numbers) {
+  let od, id, thickness;
+  const mMatch = text.match(/m(\d+)/i);
+  if (mMatch) { const s = parseInt(mMatch[1]); od = s * 2.5; id = s + 0.5; thickness = 2; }
+  else if (numbers.length >= 2) { od = numbers[0]; id = numbers[1]; thickness = numbers[2] || 2; }
+  if (!od || !id) return null;
+  return { type: 'washer', outerDiameter: r(od), innerDiameter: r(id), thickness: r(thickness) };
+}
+
+function parseSpacerCommand(text, numbers) {
+  let od, id, height;
+  if (numbers.length >= 3) { od = numbers[0]; id = numbers[1]; height = numbers[2]; }
+  else if (numbers.length >= 2) { od = numbers[0]; id = numbers[1]; height = 10; }
+  if (!od || !id) return null;
+  return { type: 'spacer', outerDiameter: r(od), innerDiameter: r(id), height: r(height) };
+}
+
+function parseGearCommand(text, numbers) {
+  let diameter, teeth, thickness;
+  const diaMatch = text.match(/(?:diameter|dia)\s*(\d+(?:\.\d+)?)/i);
+  if (diaMatch) diameter = parseFloat(diaMatch[1]);
+  const teethMatch = text.match(/(\d+)\s*(?:teeth|tooth)/i);
+  if (teethMatch) teeth = parseInt(teethMatch[1]);
+  if (!diameter && numbers.length >= 1) diameter = numbers[0];
+  if (!teeth && numbers.length >= 2) teeth = numbers[1];
+  if (!diameter || !teeth) return null;
+  thickness = numbers.length >= 3 ? numbers[2] : 10;
+  return { type: 'gear', diameter: r(diameter), teeth, thickness: r(thickness) };
+}
+
+// ============================================================================
+// OPERATION PARSERS
+// ============================================================================
+
+function parseOperations(text, numbers, commands) {
+  if (/fillet|round\s*edge|rounded/i.test(text)) {
+    const m = text.match(/(\d+(?:\.\d+)?)\s*(?:mm)?\s*fillet|fillet\s*(\d+(?:\.\d+)?)/i);
+    commands.push({ type: 'fillet', radius: r(m ? parseFloat(m[1] || m[2]) : (numbers[0] || 3)) });
+  }
+  if (/chamfer|bevel/i.test(text)) {
+    const m = text.match(/(\d+(?:\.\d+)?)\s*(?:mm)?\s*chamfer|chamfer\s*(\d+(?:\.\d+)?)/i);
+    commands.push({ type: 'chamfer', distance: r(m ? parseFloat(m[1] || m[2]) : (numbers[0] || 2)) });
+  }
+  if (/extrude|extend|pull|raise/i.test(text)) {
+    const m = text.match(/(?:extrude|pull|raise)\s*(\d+(?:\.\d+)?)|(\d+(?:\.\d+)?)\s*(?:mm)?\s*extrude/i);
+    commands.push({ type: 'extrude', height: r(m ? parseFloat(m[1] || m[2]) : (numbers[0] || 10)) });
+  }
+  if (/revolve|spin/i.test(text)) {
+    const m = text.match(/(\d+(?:\.\d+)?)\s*deg/i);
+    commands.push({ type: 'revolve', angle: m ? parseFloat(m[1]) : 360 });
+  }
+  // Hole
+  if (/\bhole\b/i.test(text)) {
+    const m = text.match(/(\d+(?:\.\d+)?)\s*(?:mm)?\s*(?:hole|diameter)|hole\s*(?:of\s*)?(\d+(?:\.\d+)?)/i);
+    const r_val = m ? parseFloat(m[1] || m[2]) / 2 : (numbers[0] ? numbers[0] / 2 : 5);
+    commands.push({ type: 'hole', radius: r(r_val) });
+  }
+}
+
+// ============================================================================
+// UTILITIES
+// ============================================================================
+
+function r(n) { return Math.round((n || 0) * 10) / 10; }
+
+export function parseNumbers(text) {
+  const numbers = [];
+  const regex = /(\d+(?:\.\d+)?)\s*(mm|cm|m|in|inch|ft|foot)?/gi;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    const val = parseFloat(match[1]);
+    const unit = (match[2] || 'mm').toLowerCase();
+    numbers.push(val * (UNIT_FACTORS[unit] || 1));
+  }
+  return numbers;
+}
+
+export function parseDimensions(text) {
+  const xMatch = text.match(/(\d+(?:\.\d+)?)\s*x\s*(\d+(?:\.\d+)?)\s*(?:x\s*(\d+(?:\.\d+)?))?/i);
+  if (xMatch) {
+    const d = [parseFloat(xMatch[1]), parseFloat(xMatch[2])];
+    if (xMatch[3]) d.push(parseFloat(xMatch[3]));
+    return d;
+  }
+  const byMatch = text.match(/(\d+(?:\.\d+)?)\s+by\s+(\d+(?:\.\d+?))\s*(?:by\s+(\d+(?:\.\d+)?))?/i);
+  if (byMatch) {
+    const d = [parseFloat(byMatch[1]), parseFloat(byMatch[2])];
+    if (byMatch[3]) d.push(parseFloat(byMatch[3]));
+    return d;
+  }
+  return [];
+}
+
+export function detectPartType(text) {
+  text = text.toLowerCase();
+
+  // 1. Exact synonym match (fast path)
+  for (const [type, synonyms] of Object.entries(PART_TYPE_SYNONYMS)) {
+    for (const syn of synonyms) {
+      if (text.includes(syn)) return type;
+    }
+  }
+
+  // 2. Dimension-only input like "100x50x20" → box
+  if (/\d+\s*x\s*\d+/.test(text)) return 'box';
+
+  // 3. Fuzzy match — handle typos like "cylindr", "spehre", "brcket"
+  const words = text.replace(/[^a-z\s]/g, '').split(/\s+/).filter(w => w.length >= 3);
+  const allTargets = [];
+  for (const [type, synonyms] of Object.entries(PART_TYPE_SYNONYMS)) {
+    for (const syn of synonyms) {
+      if (syn.includes(' ')) continue; // skip multi-word for fuzzy
+      allTargets.push({ word: syn, type });
+    }
+  }
+
+  let bestMatch = null;
+  let bestDist = Infinity;
+  for (const w of words) {
+    for (const target of allTargets) {
+      const dist = levenshtein(w, target.word);
+      const threshold = target.word.length <= 4 ? 1 : 2; // stricter for short words
+      if (dist <= threshold && dist < bestDist) {
+        bestDist = dist;
+        bestMatch = target.type;
+      }
+    }
+  }
+
+  return bestMatch;
+}
+
+// Levenshtein distance for fuzzy matching
+function levenshtein(a, b) {
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) matrix[i] = [i];
+  for (let j = 0; j <= a.length; j++) matrix[0][j] = j;
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      const cost = a[j - 1] === b[i - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1,      // deletion
+        matrix[i][j - 1] + 1,      // insertion
+        matrix[i - 1][j - 1] + cost // substitution
+      );
+    }
+  }
+  return matrix[b.length][a.length];
+}
+
+export function generateDescription(command) {
+  if (command.action) {
+    switch (command.action) {
+      case 'delete': return 'delete part';
+      case 'undo': return 'undo';
+      case 'redo': return 'redo';
+      case 'move': return `move ${command.axis} ${command.distance}mm`;
+      case 'rotate': return `rotate ${command.angle}° ${command.axis}`;
+      case 'scale': return `scale ${command.factor}x`;
+      case 'hide': return 'hide part';
+      case 'showAll': return 'show all';
+      case 'clearScene': return 'clear scene';
+      case 'duplicate': return 'duplicate';
+      case 'color': return `color ${command.color}`;
+      case 'booleanSubtract': return 'boolean subtract';
+      case 'booleanIntersect': return 'boolean intersect';
+      case 'booleanUnion': return 'boolean union';
+      case 'fitAll': return 'fit view';
+      case 'export': return `export ${command.format}`;
+      default: return command.action;
+    }
+  }
+  switch (command.type) {
+    case 'box': return `${command.width}×${command.height}×${command.depth}mm box`;
+    case 'cylinder': return `cylinder r${command.radius} h${command.height}mm`;
+    case 'sphere': return `sphere r${command.radius}mm`;
+    case 'cone': return `cone r${command.radius} h${command.height}mm`;
+    case 'torus': return `torus r${command.radius} tube${command.tube}mm`;
+    case 'bracket': return `${command.width}×${command.height}×${command.thickness}mm L-bracket`;
+    case 'plate': return `${command.width}×${command.height}×${command.thickness}mm plate`;
+    case 'flange': return `flange OD${command.outerDiameter} ID${command.innerDiameter} h${command.height}mm`;
+    case 'washer': return `washer OD${command.outerDiameter} ID${command.innerDiameter}mm`;
+    case 'spacer': return `spacer OD${command.outerDiameter} ID${command.innerDiameter} h${command.height}mm`;
+    case 'gear': return `${command.teeth}T gear d${command.diameter}mm`;
+    case 'fillet': return `${command.radius}mm fillet`;
+    case 'chamfer': return `${command.distance}mm chamfer`;
+    case 'extrude': return `extrude ${command.height}mm`;
+    case 'revolve': return `revolve ${command.angle}°`;
+    case 'hole': return `hole r${command.radius}mm`;
+    default: return JSON.stringify(command);
+  }
+}
+
+// ============================================================================
+// API KEY MANAGEMENT
+// ============================================================================
+
+export function setAPIKeys(geminiKey, groqKey) {
+  chatState.apiKeys.gemini = geminiKey || null;
+  chatState.apiKeys.groq = groqKey || null;
+  localStorage.setItem('cyclecad_api_keys', JSON.stringify(chatState.apiKeys));
+}
+
+export function getAPIKeys() {
+  return { ...chatState.apiKeys };
+}
+
+// ============================================================================
+// LEGACY EXPORTS (backward compat)
+// ============================================================================
+
+export async function parseCADPrompt(text) {
+  const lower = text.toLowerCase().trim();
+  if (chatState.apiKeys.gemini || chatState.apiKeys.groq) {
+    try {
+      const result = await querySmartLLM(text);
+      if (result?.commands?.length > 0) return result.commands;
+    } catch (e) {
+      console.warn('LLM fallback to local:', e.message);
+    }
+  }
+  return localParseCADPrompt(lower);
+}
+
 export default {
   initChat,
   addMessage,