cyclecad 3.11.0 → 3.13.0

package/app/js/modules/text-to-cad.js

@@ -41,6 +41,23 @@
     lastAction: null
   };
 
+  // Live preview state (v3.12.0) — isolated mini Three.js scene embedded in dialog.
+  // Template-matched prompts render instantly. Novel prompts require explicit Enter/Generate.
+  const preview = {
+    scene: null,
+    camera: null,
+    renderer: null,
+    controls: null,
+    group: null,         // THREE.Group holding current preview meshes
+    sketchState: null,   // { shape, width, height, radius, points, origin }
+    bodyMesh: null,      // first solid — target for ops.hole subtraction (visual)
+    lastMesh: null,      // most recent mesh — used by ops.pattern
+    raf: null,           // requestAnimationFrame handle
+    debounceTimer: null,
+    lastPrompt: '',
+    pendingLLM: false
+  };
+
   // ========== TYPEDEFS ==========
   /**
    * @typedef {Object} ParseResult
@@ -1092,13 +1109,22 @@
         <textarea
           id="ttc-input"
           class="ttc-input"
-          placeholder="e.g., 'a flanged cylinder 50mm diameter, 80mm tall with 4 bolt holes on a 70mm PCD'&#10;or 'gear with 24 teeth, module 2'"
-          rows="4"
+          placeholder="Try: 'M8 nut', '4040 t-slot extrusion 500mm', '6200 bearing', 'spur gear 20 teeth module 2'&#10;or describe freely — press Enter to generate with AI."
+          rows="3"
         ></textarea>
         <div class="ttc-input-controls">
-          <button id="ttc-generate" class="ttc-btn ttc-btn-primary">Generate (Ctrl+Enter)</button>
+          <button id="ttc-generate" class="ttc-btn ttc-btn-primary">Generate with AI</button>
           <button id="ttc-clear" class="ttc-btn ttc-btn-secondary">Clear</button>
         </div>
+        <div id="ttc-status" class="ttc-status ttc-status-idle">Start typing to see a live preview</div>
+      </div>
+
+      <div class="ttc-livepreview-section">
+        <div id="ttc-preview-mount" class="ttc-preview-mount"></div>
+        <div class="ttc-preview-actions">
+          <button id="ttc-insert" class="ttc-btn ttc-btn-primary" disabled>Insert into scene</button>
+          <button id="ttc-download-stl" class="ttc-btn ttc-btn-secondary" disabled>Download STL</button>
+        </div>
       </div>
 
       <div class="ttc-preview-section">
@@ -1437,9 +1463,508 @@
         background: var(--border-color);
         border-color: var(--accent-blue);
       }
+
+      .ttc-status {
+        padding: 6px 8px;
+        border-radius: 3px;
+        font-size: 11px;
+        border-left: 3px solid transparent;
+        transition: all var(--transition-fast);
+      }
+      .ttc-status-idle    { background: #0f172a; color: #94a3b8; border-left-color: #334155; }
+      .ttc-status-template{ background: #052e26; color: #6ee7b7; border-left-color: #10b981; }
+      .ttc-status-pending { background: #1e1b4b; color: #c4b5fd; border-left-color: #8b5cf6; }
+      .ttc-status-error   { background: #2a0f0f; color: #fca5a5; border-left-color: #ef4444; }
+      .ttc-status-working { background: #1e293b; color: #7dd3fc; border-left-color: #38bdf8; }
+
+      .ttc-livepreview-section {
+        display: flex;
+        flex-direction: column;
+        gap: 6px;
+        padding: 8px;
+        background: #0f172a;
+        border: 1px solid var(--border-color);
+        border-radius: 3px;
+      }
+      .ttc-preview-mount {
+        width: 100%;
+        height: 280px;
+        background: #0b1220;
+        border-radius: 3px;
+        overflow: hidden;
+        position: relative;
+      }
+      .ttc-preview-mount canvas {
+        display: block;
+        width: 100% !important;
+        height: 100% !important;
+      }
+      .ttc-preview-actions {
+        display: flex;
+        gap: 6px;
+      }
     `;
   }
 
+  // ========== LIVE PREVIEW ENGINE (template-matched + debounced) ==========
+
+  /**
+   * Set up a dedicated Three.js preview scene inside the dialog.
+   * Called once when the UI is first mounted.
+   * @param {HTMLElement} mount - Container element for the preview canvas
+   */
+  function setupPreviewScene(mount) {
+    if (!window.THREE || !mount) return;
+    const THREE = window.THREE;
+    const w = mount.clientWidth || 360;
+    const h = mount.clientHeight || 280;
+
+    preview.scene = new THREE.Scene();
+    preview.scene.background = new THREE.Color(0x0b1220);
+
+    preview.camera = new THREE.PerspectiveCamera(45, w / h, 0.1, 5000);
+    preview.camera.position.set(180, 180, 180);
+    preview.camera.lookAt(0, 0, 0);
+
+    preview.renderer = new THREE.WebGLRenderer({ antialias: true, alpha: false });
+    preview.renderer.setPixelRatio(window.devicePixelRatio || 1);
+    preview.renderer.setSize(w, h, false);
+    mount.appendChild(preview.renderer.domElement);
+
+    const hemi = new THREE.HemisphereLight(0xffffff, 0x444466, 0.8);
+    preview.scene.add(hemi);
+    const dir = new THREE.DirectionalLight(0xffffff, 0.6);
+    dir.position.set(150, 250, 100);
+    preview.scene.add(dir);
+
+    const grid = new THREE.GridHelper(200, 20, 0x1f2937, 0x1f2937);
+    grid.position.y = -0.01;
+    preview.scene.add(grid);
+
+    // Simple orbit: mouse drag rotates around target.
+    let dragging = false, lastX = 0, lastY = 0, yaw = Math.PI / 4, pitch = Math.PI / 5, dist = 260;
+    const canvas = preview.renderer.domElement;
+    const applyCam = () => {
+      const x = Math.cos(pitch) * Math.cos(yaw) * dist;
+      const y = Math.sin(pitch) * dist;
+      const z = Math.cos(pitch) * Math.sin(yaw) * dist;
+      preview.camera.position.set(x, y, z);
+      preview.camera.lookAt(0, 0, 0);
+    };
+    applyCam();
+    canvas.addEventListener('pointerdown', (e) => { dragging = true; lastX = e.clientX; lastY = e.clientY; canvas.setPointerCapture(e.pointerId); });
+    canvas.addEventListener('pointerup', (e) => { dragging = false; try { canvas.releasePointerCapture(e.pointerId); } catch(_){} });
+    canvas.addEventListener('pointermove', (e) => {
+      if (!dragging) return;
+      yaw -= (e.clientX - lastX) * 0.01;
+      pitch = Math.max(-1.3, Math.min(1.3, pitch + (e.clientY - lastY) * 0.01));
+      lastX = e.clientX; lastY = e.clientY;
+      applyCam();
+    });
+    canvas.addEventListener('wheel', (e) => {
+      e.preventDefault();
+      dist = Math.max(40, Math.min(2000, dist * (1 + Math.sign(e.deltaY) * 0.1)));
+      applyCam();
+    }, { passive: false });
+    preview._applyCam = applyCam;
+    preview._getDist = () => dist;
+    preview._setDist = (d) => { dist = d; applyCam(); };
+
+    const tick = () => {
+      if (!preview.renderer) return;
+      preview.renderer.render(preview.scene, preview.camera);
+      preview.raf = requestAnimationFrame(tick);
+    };
+    tick();
+
+    // Handle container resizing.
+    if (window.ResizeObserver) {
+      const ro = new ResizeObserver(() => {
+        if (!preview.renderer) return;
+        const nw = mount.clientWidth || 360, nh = mount.clientHeight || 280;
+        preview.renderer.setSize(nw, nh, false);
+        preview.camera.aspect = nw / nh;
+        preview.camera.updateProjectionMatrix();
+      });
+      ro.observe(mount);
+    }
+  }
+
+  /**
+   * Clear the preview group (remove all meshes, reset state).
+   */
+  function clearPreview() {
+    if (!preview.scene) return;
+    if (preview.group) {
+      preview.scene.remove(preview.group);
+      preview.group.traverse(obj => {
+        if (obj.geometry) obj.geometry.dispose();
+        if (obj.material) {
+          if (Array.isArray(obj.material)) obj.material.forEach(m => m.dispose());
+          else obj.material.dispose();
+        }
+      });
+    }
+    preview.group = new window.THREE.Group();
+    preview.group.name = 'TextToCADPreview';
+    preview.scene.add(preview.group);
+    preview.sketchState = null;
+    preview.bodyMesh = null;
+    preview.lastMesh = null;
+  }
+
+  /**
+   * Helper: extract [x,y,z] position from step params.
+   */
+  function previewGetPos(p) {
+    if (Array.isArray(p.position)) return p.position;
+    if (Array.isArray(p.center)) return p.center;
+    if (Array.isArray(p.at)) return p.at;
+    return [+p.x || 0, +p.y || 0, +p.z || 0];
+  }
+
+  /**
+   * Mini executor that runs a single plan step against the preview scene.
+   * Mirrors the methods AICopilot.miniExecute supports, but writes into preview.group
+   * instead of window._scene. Subtraction is visual-only (no CSG) to keep it fast.
+   * @param {{method:string, params:Object}} step
+   */
+  function previewExecutor(step) {
+    if (!preview.scene || !window.THREE) return;
+    const THREE = window.THREE;
+    const method = step.method;
+    const params = step.params || {};
+
+    if (method === 'sketch.start') {
+      preview.sketchState = { plane: params.plane || 'XY', origin: previewGetPos(params) };
+      return;
+    }
+    if (method === 'sketch.rect') {
+      preview.sketchState = Object.assign(preview.sketchState || {}, {
+        shape: 'rect',
+        width: params.width || params.w || 50,
+        height: params.height || params.h || 30,
+        origin: previewGetPos(params)
+      });
+      return;
+    }
+    if (method === 'sketch.circle') {
+      preview.sketchState = Object.assign(preview.sketchState || {}, {
+        shape: 'circle',
+        radius: params.radius || params.r || (params.diameter ? params.diameter / 2 : 25),
+        origin: previewGetPos(params)
+      });
+      return;
+    }
+    if (method === 'sketch.polyline' || method === 'sketch.polygon') {
+      const raw = Array.isArray(params.points) ? params.points : [];
+      const pts = raw.filter(p => Array.isArray(p) && p.length >= 2).map(p => [Number(p[0]) || 0, Number(p[1]) || 0]);
+      if (pts.length < 3) return;
+      preview.sketchState = Object.assign(preview.sketchState || {}, {
+        shape: 'polyline',
+        points: pts,
+        origin: previewGetPos(params)
+      });
+      return;
+    }
+    if (method === 'sketch.line' || method === 'sketch.end') return;
+
+    if (method === 'ops.extrude') {
+      const d = params.depth || params.height || params.distance || 20;
+      const sk = preview.sketchState || {};
+      const explicit = (Array.isArray(params.position) || params.x !== undefined) ? previewGetPos(params) : null;
+      const pos = explicit || sk.origin || [0, 0, 0];
+      let g;
+      if (sk.shape === 'rect') g = new THREE.BoxGeometry(sk.width, d, sk.height);
+      else if (sk.shape === 'circle') g = new THREE.CylinderGeometry(sk.radius, sk.radius, d, 48);
+      else if (sk.shape === 'polyline' && Array.isArray(sk.points) && sk.points.length >= 3) {
+        const shape = new THREE.Shape();
+        const pts = sk.points;
+        shape.moveTo(pts[0][0], -pts[0][1]);
+        for (let i = 1; i < pts.length; i++) shape.lineTo(pts[i][0], -pts[i][1]);
+        shape.closePath();
+        g = new THREE.ExtrudeGeometry(shape, { depth: d, bevelEnabled: false, curveSegments: 24 });
+        g.translate(0, 0, -d / 2);
+        g.rotateX(-Math.PI / 2);
+      } else {
+        g = new THREE.BoxGeometry(50, d, 30);
+      }
+      const isSub = params.subtract === true || params.operation === 'cut' || params.operation === 'subtract';
+      const mat = new THREE.MeshStandardMaterial({
+        color: isSub ? 0x1a1a1a : 0x38bdf8,
+        metalness: 0.3,
+        roughness: 0.5
+      });
+      const mesh = new THREE.Mesh(g, mat);
+      mesh.position.set(pos[0] || 0, (pos[1] || 0) + d / 2, pos[2] || 0);
+      preview.group.add(mesh);
+      preview.lastMesh = mesh;
+      if (!preview.bodyMesh && !isSub) preview.bodyMesh = mesh;
+      preview.sketchState = null;
+      return;
+    }
+
+    if (method === 'ops.hole' || method === 'ops.subtract' || method === 'ops.cut') {
+      // Visual-only: mark the cut region with a dark cylinder/box (no CSG to keep preview fast).
+      const pos = previewGetPos(params);
+      const d = params.depth || 25;
+      let g;
+      if (params.width && params.height) {
+        g = new THREE.BoxGeometry(params.width, d, params.height);
+      } else {
+        const r = params.radius || (params.diameter ? params.diameter / 2 : 3);
+        g = new THREE.CylinderGeometry(r, r, d, 32);
+      }
+      const mat = new THREE.MeshStandardMaterial({ color: 0x111827, metalness: 0.1, roughness: 0.9 });
+      const mesh = new THREE.Mesh(g, mat);
+      mesh.position.set(pos[0] || 0, (pos[1] || 0) + d / 2 - 0.5, pos[2] || 0);
+      preview.group.add(mesh);
+      return;
+    }
+
+    if (method === 'ops.pattern') {
+      if (!preview.lastMesh) return;
+      const count = Math.max(2, Math.min(20, params.count || 4));
+      const sx = params.spacingX || (params.direction === 'x' ? params.spacing : 0) || 0;
+      const sz = params.spacingZ || (params.direction === 'z' ? params.spacing : 0) || 0;
+      const sy = params.spacingY || 0;
+      for (let i = 1; i < count; i++) {
+        const c = preview.lastMesh.clone();
+        c.position.x += sx * i;
+        c.position.z += sz * i;
+        c.position.y += sy * i;
+        preview.group.add(c);
+      }
+      return;
+    }
+
+    if (method === 'view.fit') {
+      if (!preview.group || !preview.camera) return;
+      const box = new THREE.Box3().setFromObject(preview.group);
+      if (box.isEmpty()) return;
+      const size = box.getSize(new THREE.Vector3());
+      const maxDim = Math.max(size.x, size.y, size.z) || 100;
+      const fov = (preview.camera.fov || 45) * Math.PI / 180;
+      const dist = maxDim / (2 * Math.tan(fov / 2)) * 2.3;
+      if (preview._setDist) preview._setDist(dist);
+      return;
+    }
+    if (method === 'view.set') return;  // honour iso default
+    // Unknown/stub methods: ignore silently.
+  }
+
+  /**
+   * Run a plan (array of steps) against the preview scene.
+   * @param {Array} plan
+   */
+  function runPlanInPreview(plan) {
+    if (!Array.isArray(plan)) return;
+    clearPreview();
+    for (const step of plan) {
+      try { previewExecutor(step); } catch (_) { /* continue */ }
+    }
+    // Ensure a fit pass ran.
+    try { previewExecutor({ method: 'view.fit', params: {} }); } catch (_) {}
+  }
+
+  /**
+   * Debounced handler: called on every keystroke.
+   * Fast path: if matchTemplate returns a plan, render it immediately and show success badge.
+   * Slow path: show "Press Enter" hint — no LLM call until user confirms.
+   * @param {string} promptText
+   */
+  function onPromptTyped(promptText) {
+    if (preview.debounceTimer) clearTimeout(preview.debounceTimer);
+    const trimmed = (promptText || '').trim();
+    if (trimmed.length === 0) {
+      setStatus('Start typing to see a live preview', 'idle');
+      clearPreview();
+      setInsertEnabled(false);
+      return;
+    }
+    preview.debounceTimer = setTimeout(() => {
+      preview.lastPrompt = trimmed;
+      let plan = null;
+      try {
+        if (window.CycleCAD && window.CycleCAD.AICopilot && typeof window.CycleCAD.AICopilot.matchTemplate === 'function') {
+          plan = window.CycleCAD.AICopilot.matchTemplate(trimmed);
+        }
+      } catch (_) { plan = null; }
+      if (Array.isArray(plan) && plan.length > 0) {
+        runPlanInPreview(plan);
+        setStatus('Template matched (' + plan.length + ' step' + (plan.length === 1 ? '' : 's') + ') — adjust or Insert into scene', 'template');
+        setInsertEnabled(true);
+      } else {
+        // No template match. Try the built-in NLP parser as a secondary fast path.
+        try {
+          const spec = parseDescription(trimmed);
+          const geom = spec ? generateGeometry(spec) : null;
+          if (geom) {
+            clearPreview();
+            geom.traverse(m => {
+              if (m.material) { m.material.opacity = 1; m.material.transparent = false; }
+            });
+            preview.group.add(geom);
+            // Auto-fit.
+            previewExecutor({ method: 'view.fit', params: {} });
+            setStatus('Parsed locally (confidence ' + Math.round(spec.confidence * 100) + '%) — press Enter for AI refinement', 'template');
+            setInsertEnabled(true);
+            return;
+          }
+        } catch (_) { /* fall through */ }
+        setStatus('No template match — press Enter to generate with AI', 'pending');
+        setInsertEnabled(false);
+      }
+    }, 400);
+  }
+
+  /**
+   * Update the status badge.
+   * @param {string} text
+   * @param {'idle'|'template'|'pending'|'error'|'working'} kind
+   */
+  function setStatus(text, kind) {
+    const el = document.querySelector('#ttc-status');
+    if (!el) return;
+    el.textContent = text;
+    el.className = 'ttc-status ttc-status-' + (kind || 'idle');
+  }
+
+  /**
+   * Enable/disable the Insert and Download buttons.
+   */
+  function setInsertEnabled(enabled) {
+    const ins = document.querySelector('#ttc-insert');
+    const dl = document.querySelector('#ttc-download-stl');
+    if (ins) ins.disabled = !enabled;
+    if (dl) dl.disabled = !enabled;
+  }
+
+  /**
+   * Copy the current preview geometry into the main cycleCAD scene.
+   */
+  function insertPreviewIntoMainScene() {
+    if (!preview.group || preview.group.children.length === 0) return;
+    const mainScene = (state.scene) || window._scene;
+    if (!mainScene || !window.THREE) {
+      setStatus('Main scene not available', 'error');
+      return;
+    }
+    const clone = new window.THREE.Group();
+    clone.name = 'TextToCAD_' + Date.now();
+    preview.group.children.forEach(child => {
+      const c = child.clone();
+      if (c.material && c.material.clone) c.material = c.material.clone();
+      clone.add(c);
+    });
+    mainScene.add(clone);
+    state.currentGeometry = clone;
+    addStep({ input: preview.lastPrompt || 'Text-to-CAD', geometry: clone, timestamp: Date.now() });
+    setStatus('Inserted into main scene', 'template');
+  }
+
+  /**
+   * Generate an ASCII STL string from the current preview group.
+   * @returns {string}
+   */
+  function previewToSTL() {
+    if (!preview.group || !window.THREE) return '';
+    const THREE = window.THREE;
+    const lines = ['solid TextToCAD'];
+    const v = new THREE.Vector3();
+    const m = new THREE.Matrix4();
+    preview.group.traverse(obj => {
+      if (!obj.isMesh || !obj.geometry) return;
+      const geom = obj.geometry.index ? obj.geometry.toNonIndexed() : obj.geometry;
+      const pos = geom.getAttribute('position');
+      if (!pos) return;
+      obj.updateMatrixWorld(true);
+      m.copy(obj.matrixWorld);
+      for (let i = 0; i < pos.count; i += 3) {
+        const a = new THREE.Vector3().fromBufferAttribute(pos, i).applyMatrix4(m);
+        const b = new THREE.Vector3().fromBufferAttribute(pos, i + 1).applyMatrix4(m);
+        const c = new THREE.Vector3().fromBufferAttribute(pos, i + 2).applyMatrix4(m);
+        const n = new THREE.Vector3().subVectors(b, a).cross(new THREE.Vector3().subVectors(c, a)).normalize();
+        lines.push('  facet normal ' + n.x.toFixed(6) + ' ' + n.y.toFixed(6) + ' ' + n.z.toFixed(6));
+        lines.push('    outer loop');
+        lines.push('      vertex ' + a.x.toFixed(6) + ' ' + a.y.toFixed(6) + ' ' + a.z.toFixed(6));
+        lines.push('      vertex ' + b.x.toFixed(6) + ' ' + b.y.toFixed(6) + ' ' + b.z.toFixed(6));
+        lines.push('      vertex ' + c.x.toFixed(6) + ' ' + c.y.toFixed(6) + ' ' + c.z.toFixed(6));
+        lines.push('    endloop');
+        lines.push('  endfacet');
+      }
+    });
+    lines.push('endsolid TextToCAD');
+    return lines.join('\n');
+  }
+
+  /**
+   * Trigger a download of the current preview as an ASCII STL file.
+   */
+  function downloadPreviewSTL() {
+    const stl = previewToSTL();
+    if (!stl) return;
+    const blob = new Blob([stl], { type: 'model/stl' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = 'text-to-cad-' + Date.now() + '.stl';
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    setTimeout(() => URL.revokeObjectURL(url), 500);
+  }
+
+  /**
+   * Confirm-generate: called when user presses Enter or clicks Generate.
+   * If no template matched, this is where an LLM call would go. For now we:
+   *   1. Re-attempt matchTemplate (in case user added more text)
+   *   2. Fall back to the built-in NLP parseDescription/generateGeometry
+   *   3. Trigger AICopilot.execute('generate', ...) if available (hand off to LLM UI)
+   */
+  function confirmGenerate(promptText) {
+    const trimmed = (promptText || '').trim();
+    if (!trimmed) return;
+    preview.lastPrompt = trimmed;
+    setStatus('Generating...', 'working');
+
+    let plan = null;
+    try {
+      if (window.CycleCAD && window.CycleCAD.AICopilot && typeof window.CycleCAD.AICopilot.matchTemplate === 'function') {
+        plan = window.CycleCAD.AICopilot.matchTemplate(trimmed);
+      }
+    } catch (_) { plan = null; }
+    if (Array.isArray(plan) && plan.length > 0) {
+      runPlanInPreview(plan);
+      setStatus('Template matched (' + plan.length + ' steps)', 'template');
+      setInsertEnabled(true);
+      return;
+    }
+    // Try local NLP parser.
+    try {
+      const spec = parseDescription(trimmed);
+      const geom = spec ? generateGeometry(spec) : null;
+      if (geom) {
+        clearPreview();
+        preview.group.add(geom);
+        previewExecutor({ method: 'view.fit', params: {} });
+        setStatus('Parsed locally (confidence ' + Math.round(spec.confidence * 100) + '%)', 'template');
+        setInsertEnabled(true);
+        return;
+      }
+    } catch (_) {}
+
+    // Hand off to AI Copilot LLM pipeline if available.
+    if (window.CycleCAD && window.CycleCAD.AICopilot && typeof window.CycleCAD.AICopilot.execute === 'function') {
+      try {
+        window.CycleCAD.AICopilot.execute('generate', { prompt: trimmed });
+        setStatus('Sent to AI Copilot — switch to Copilot panel to view progress', 'working');
+        return;
+      } catch (_) {}
+    }
+    setStatus('Unable to parse — try a simpler prompt like "M8 nut"', 'error');
+  }
+
   /**
    * Initialize module
    * @param {THREE.Scene} scene
@@ -1470,58 +1995,63 @@
     const livePreviewCheckbox = container.querySelector('#ttc-live-preview');
     const undoBtn = container.querySelector('#ttc-undo');
     const redoBtn = container.querySelector('#ttc-redo');
+    const insertBtn = container.querySelector('#ttc-insert');
+    const downloadBtn = container.querySelector('#ttc-download-stl');
+    const previewMount = container.querySelector('#ttc-preview-mount');
     const examples = container.querySelectorAll('.ttc-example');
 
-    // Input handling
+    // Initialize the live preview scene (once per mount).
+    if (previewMount && !preview.scene) {
+      try { setupPreviewScene(previewMount); clearPreview(); } catch (_) {}
+    }
+
+    // Input handling — debounced live preview via template matcher.
     if (input) {
       input.addEventListener('input', (e) => {
-        if (livePreviewCheckbox && livePreviewCheckbox.checked) {
-          updateLivePreview(e.target.value);
-        }
+        onPromptTyped(e.target.value);
       });
 
       input.addEventListener('keydown', (e) => {
-        if (e.ctrlKey && e.key === 'Enter') {
-          generateBtn.click();
+        // Enter (no shift) or Ctrl/Cmd+Enter → confirm generation.
+        if ((e.key === 'Enter' && !e.shiftKey) || ((e.ctrlKey || e.metaKey) && e.key === 'Enter')) {
+          e.preventDefault();
+          confirmGenerate(input.value);
         }
       });
     }
 
-    // Generate button
+    // Generate button → same as Enter.
     if (generateBtn) {
       generateBtn.addEventListener('click', () => {
-        if (input) {
-          const spec = parseDescription(input.value);
-          if (spec) {
-            const geometry = generateGeometry(spec);
-            if (geometry) {
-              commitPreview();
-            }
-          }
-        }
+        if (input) confirmGenerate(input.value);
       });
     }
 
-    // Clear button
+    // Clear button.
     if (clearBtn) {
       clearBtn.addEventListener('click', () => {
         if (input) input.value = '';
-        if (state.previewGeometry && state.scene) {
-          state.scene.remove(state.previewGeometry);
-          state.previewGeometry = null;
-        }
+        clearPreview();
+        setStatus('Start typing to see a live preview', 'idle');
+        setInsertEnabled(false);
       });
     }
 
-    // Undo/Redo
-    if (undoBtn) {
-      undoBtn.addEventListener('click', undoStep);
+    // Insert into main scene.
+    if (insertBtn) {
+      insertBtn.addEventListener('click', insertPreviewIntoMainScene);
     }
-    if (redoBtn) {
-      redoBtn.addEventListener('click', redoStep);
+
+    // Download STL.
+    if (downloadBtn) {
+      downloadBtn.addEventListener('click', downloadPreviewSTL);
     }
 
-    // Example prompts
+    // Undo/Redo (legacy).
+    if (undoBtn) undoBtn.addEventListener('click', undoStep);
+    if (redoBtn) redoBtn.addEventListener('click', redoStep);
+
+    // Example prompts.
     examples.forEach(example => {
       example.addEventListener('click', () => {
         if (input) {
@@ -1531,7 +2061,7 @@
       });
     });
 
-    // Live preview toggle
+    // Legacy live-preview checkbox (still supported).
     if (livePreviewCheckbox) {
       livePreviewCheckbox.addEventListener('change', (e) => {
         if (!e.target.checked && state.previewGeometry && state.scene) {
@@ -1540,8 +2070,6 @@
         }
       });
     }
-
-    console.log('TextToCAD module initialized');
   }
 
   /**