cyclecad 3.10.2 → 3.10.4

package/CLAUDE.md

@@ -1119,3 +1119,88 @@ import { startSketch, endSketch, setTool, getEntities, clearSketch, entitiesToGe
 
 # currentDate
 Today's date is 2026-04-01.
+
+## Session 2026-04-23 — AI Copilot Template Library + Real CSG
+
+### What shipped
+- **cyclecad@3.10.2** (live on npm): AI Copilot v1.1 with template library, real CSG booleans, draggable dialogs, click-pin menus
+- **cyclecad@3.10.3** (pending/retry): template expansion with 5 more shapes (washer, flange, threaded rod, mounting plate, box)
+
+### Key files
+- `app/js/modules/ai-copilot.js` (~900 lines) — multi-step CAD copilot. IIFE that sets `window.CycleCAD.AICopilot`. Key internals: `matchTemplate()`, `miniExecute()` (async), `subtractFromBody()` (CSG), `loadCSG()` (lazy import vendored lib), `run()` (orchestrator), `buildUI()`
+- `app/js/vendor/three-bvh-csg.js` (3892 lines) — vendored three-bvh-csg@0.0.17 with bare imports rewritten: `'three'` and `'three-mesh-bvh'` → CDN URLs (`cdn.jsdelivr.net/npm/three@0.170.0/...` and `three-mesh-bvh@0.7.8`)
+- `app/index.html` — has `<script src="/app/js/modules/ai-copilot.js?v=HASH">` (cache-busted) and menu entry `data-action="tools-ai-copilot"`
+
+### Template library (8 shapes) — `matchTemplate(prompt)` in ai-copilot.js
+All templates bypass LLM and output a fixed JSON plan with correct DIN/ISO coordinates:
+| Prompt pattern | Shape | Notes |
+|---|---|---|
+| `raspberry pi \| rpi \| pi 4` + `case` | Pi case | Case body 89×14×60, 4 mounting posts at ±38.75, y=14, ±26. Optional USB/HDMI/Ethernet ops.hole cutouts |
+| `M(n) nut` | Hex nut (DIN 934) | Cylinder with correct across-flats + thickness by M-size |
+| `L-bracket` + `Nmm` + `N holes` + `Nmm centers` | L-bracket | Rect plate + N CSG holes |
+| `M(n) washer` or `DIN 125 M(n)` | Washer | Disk + center hole, DIN 125 spec |
+| `flange` + `Nmm` + `N bolt holes` + `PCD N` | Flange | Disk + bolt circle + center bore |
+| `threaded rod` + `M(n)` + `Nmm` | Threaded rod | Cylinder by M-size + length |
+| `mounting plate` + `NxN` + `N holes` | Mounting plate | Rect + N holes (4-hole = corners, else evenly spaced) |
+| `box NxNxN` | Generic box | Box extrude |
+
+### Coordinate system (for mini-executor)
+- X = left/right, Y = up, Z = front/back
+- All solids centered at origin: rect W×H → [-W/2,W/2] × [-H/2,H/2]
+- ops.extrude depth=D → Y spans [0, D]
+- Params `position:[x,y,z]` places the centerpoint of the extruded solid
+
+### Mini-executor API (handles these methods)
+- `sketch.start/rect/circle/line/end`
+- `ops.extrude {depth, position, subtract}` — subtract:true does CSG cut
+- `ops.hole {position, depth, radius OR width+height}` — CSG subtraction from body
+- `ops.revolve/fillet/chamfer/shell/pattern` (fillet/chamfer/shell are visual-approx only)
+- `view.set/fit`, `query.*`, `validate.*`
+
+### State (IIFE-local `miniState`)
+- `miniState.group` — THREE.Group with name 'AICopilotBuild' (wiped on every `run()` via `miniReset()`)
+- `miniState.body` — first solid mesh; ALL `ops.hole` subtractions target this (not lastMesh)
+- `miniState.lastMesh` — last added mesh; used by `ops.pattern` for cloning
+- `miniState.currentSketch` — `{shape, width, height, radius, origin}` consumed by next `ops.extrude`
+
+### Critical bug patterns fixed this session
+1. **Single-quote apostrophe in SYSTEM_PROMPT** — `isn't` closed the JS string. Use `is not` or escape.
+2. **Module not loading** — `window.CycleCAD.AICopilot` was undefined because wrapped import had syntax error. Always `node --check` the file before push.
+3. **Base64 2-chunk delivery corrupts file** — large files clipboard-split and concatenated via bash can lose the first half. Prefer single `cat > file << 'EOF'` heredoc.
+4. **Scene accumulates between runs** — `miniReset()` must be called at start of `run()`. This call was dropped twice in earlier patches.
+5. **ops.hole eating posts instead of body** — `subtractFromLast` targeted whatever was most recently added. Fixed by tracking `miniState.body` separately and calling `subtractFromBody`.
+6. **Posts landing at origin** — `ops.extrude` was ignoring `params.position` and only reading `sketch.origin`. Fixed to read params first.
+7. **Bare imports in vendored library** — `'three-mesh-bvh'` also needed rewriting, not just `'three'`.
+8. **Cmd+C hijacking Copy** — killer-features.js shortcuts had no Shift modifier. Changed to Cmd+Shift+C/K/P/G/T.
+
+### Click-pin menu (in index.html)
+CSS: `.menu-item.open .menu-dropdown { display: flex !important; }`. JS initMenuPin() wires click-to-toggle + click-outside-to-close. File still has the `:hover` fallback for quick hover.
+
+### Dialog drag (in index.html)
+Pointer events on `#dialog-title` drag the whole dialog container via `position: fixed; left/top` — set once on pointerdown, updated on pointermove.
+
+### UX niceties
+- Banner: `Ready: <model>` (green) or `No <provider> key — click the key icon` (red)
+- Low-credit errors auto-offer "Switch to Gemini (free)" button
+- Multi-goal prompts: detect `N` quoted strings, run first, log others to "paste one at a time"
+- Gemini 404 fallback: `gemini-2.0-flash` → `gemini-1.5-flash` → `gemini-1.5-flash-latest`
+- Cache-bust: `?v=HASH` query param on script tags, auto-bumped by MD5 of mtime
+
+### Supported models
+- Claude Sonnet 4.6 (paid, default when anthropic key present)
+- Claude Haiku 4.5 / Opus 4.6 (paid)
+- Gemini 2.0 Flash (free, 10 RPM)
+- Groq Llama 3.3 70B (free, 30 RPM — better for repeat prompts)
+
+### Pending
+- Retry `npm publish cyclecad@3.10.3` (earlier attempt interrupted; registry still shows 3.10.2)
+- Add gear/pulley/shaft templates (Task #7)
+- Verify ExplodeView redirects
+- The `block-only-in-chrome` user report — needs repro with actual prompt
+
+### Collaboration notes
+- User on Mac, tests in Chrome/Safari private
+- Git user is `sachin@sachins-MacBook-Air.fritz.box` (not configured globally; harmless warning)
+- Clipboard delivery via `write_clipboard` — user pastes in Terminal
+- Verification via Claude-in-Chrome MCP (navigate → execute → screenshot → dom inspect)
+- Terminal is tier-click, so clipboard write is BLOCKED while Terminal is frontmost — switch to Chrome first

package/app/index.html

@@ -1538,7 +1538,7 @@ window._dismissSplash = function(action) {
 
 <!-- Killer Feature Modules -->
 <script src="/app/js/agent-api.js?v=a41b98a5"></script>
-<script src="/app/js/modules/ai-copilot.js?v=407987b9"></script>
+<script src="/app/js/modules/ai-copilot.js?v=14e5d5d7"></script>
 <script src="/app/js/modules/text-to-cad.js"></script>
 <script src="/app/js/modules/photo-to-cad.js"></script>
 <script src="/app/js/modules/manufacturability.js"></script>

package/app/js/modules/ai-copilot.js

@@ -390,7 +390,105 @@
         {method:'view.fit', params:{}}
       ];
     }
-    // L-bracket with holes
+    // DIN 125 washer (M3-M12)
+    const washerM = p.match(/\bm(\d+)\s*washer|washer\s+m(\d+)|din\s*125\s*m?(\d+)/);
+    if (washerM) {
+      const size = parseInt(washerM[1]||washerM[2]||washerM[3]);
+      const outerR = ({3:3.5, 4:4.5, 5:5.3, 6:6.4, 8:8.4, 10:10.5, 12:13})[size] || size*1.2;
+      const thick  = ({3:0.5, 4:0.8, 5:1,   6:1.6, 8:1.6, 10:2,    12:2.5})[size] || size*0.2;
+      const holeR = (size + 0.4) / 2;
+      return [
+        {method:'sketch.start', params:{plane:'XY'}},
+        {method:'sketch.circle', params:{radius: outerR}},
+        {method:'ops.extrude', params:{depth: thick, position:[0,0,0]}, note:'DIN 125 M'+size+' washer'},
+        {method:'ops.hole', params:{position:[0, thick, 0], radius: holeR, depth: thick+2}, note:'M'+size+' hole'},
+        {method:'view.set', params:{view:'iso'}},
+        {method:'view.fit', params:{}}
+      ];
+    }
+    // Flange with bolt circle
+    const flangeM = p.match(/flange/);
+    if (flangeM) {
+      const odM = p.match(/(\d+)\s*mm/);
+      const od = odM ? parseInt(odM[1]) : 80;
+      const nM = p.match(/(\d+)\s*(?:bolt\s*)?holes?/);
+      const nHoles = nM ? parseInt(nM[1]) : 4;
+      const pcdM = p.match(/pcd\s*(\d+)|bolt\s*circle\s*(\d+)/);
+      const pcd = pcdM ? parseInt(pcdM[1]||pcdM[2]) : Math.round(od*0.7);
+      const thick = 8;
+      const plan = [
+        {method:'sketch.start', params:{plane:'XY'}},
+        {method:'sketch.circle', params:{radius: od/2}},
+        {method:'ops.extrude', params:{depth: thick, position:[0,0,0]}, note:'flange body Ø'+od},
+        {method:'ops.hole', params:{position:[0, thick, 0], radius: Math.max(5, od/8), depth: thick+2}, note:'center bore'}
+      ];
+      for (let i = 0; i < nHoles; i++) {
+        const a = (i / nHoles) * Math.PI * 2;
+        const x = Math.cos(a) * pcd/2, z = Math.sin(a) * pcd/2;
+        plan.push({method:'ops.hole', params:{position:[x, thick/2, z], radius: 3, depth: thick+2}, note:'bolt hole '+(i+1)+'/'+nHoles});
+      }
+      plan.push({method:'view.set', params:{view:'iso'}});
+      plan.push({method:'view.fit', params:{}});
+      return plan;
+    }
+    // Threaded rod / stud
+    const rodM = p.match(/threaded\s*rod|m(\d+)\s*rod|m(\d+)\s*stud|studding/);
+    if (rodM) {
+      const sM = p.match(/m(\d+)/);
+      const size = sM ? parseInt(sM[1]) : 8;
+      const lM = p.match(/(\d+)\s*mm/);
+      const len = lM ? parseInt(lM[1]) : 100;
+      return [
+        {method:'sketch.start', params:{plane:'XY'}},
+        {method:'sketch.circle', params:{radius: size/2}},
+        {method:'ops.extrude', params:{depth: len, position:[0,0,0]}, note:'M'+size+' threaded rod, '+len+'mm long'},
+        {method:'view.set', params:{view:'iso'}},
+        {method:'view.fit', params:{}}
+      ];
+    }
+    // Mounting plate
+    const plateM = p.match(/mounting\s*plate|base\s*plate|flat\s*plate/);
+    if (plateM) {
+      const dimM = p.match(/(\d+)\s*x\s*(\d+)/);
+      const w = dimM ? parseInt(dimM[1]) : 120;
+      const h = dimM ? parseInt(dimM[2]) : 80;
+      const thick = 6;
+      const nM = p.match(/(\d+)\s*holes?/);
+      const nHoles = nM ? parseInt(nM[1]) : 4;
+      const plan = [
+        {method:'sketch.start', params:{plane:'XY'}},
+        {method:'sketch.rect', params:{width: w, height: h}},
+        {method:'ops.extrude', params:{depth: thick, position:[0,0,0]}, note: w+'x'+h+'x'+thick+' mounting plate'}
+      ];
+      if (nHoles === 4) {
+        const mx = w/2 - 10, mz = h/2 - 10;
+        [[-mx,-mz],[mx,-mz],[-mx,mz],[mx,mz]].forEach((pp,i) => {
+          plan.push({method:'ops.hole', params:{position:[pp[0], thick/2, pp[1]], radius:3, depth:thick+2}, note:'corner hole '+(i+1)});
+        });
+      } else {
+        for (let i = 0; i < nHoles; i++) {
+          const x = -w/2 + 10 + (i/(nHoles-1)) * (w-20);
+          plan.push({method:'ops.hole', params:{position:[x, thick/2, 0], radius:3, depth:thick+2}, note:'hole '+(i+1)});
+        }
+      }
+      plan.push({method:'view.set', params:{view:'iso'}});
+      plan.push({method:'view.fit', params:{}});
+      return plan;
+    }
+    // Generic box NxNxN with optional fillet
+    const boxM = p.match(/\bbox\b|\bblock\b|\bcube\b|\bcuboid\b/);
+    const boxDim = p.match(/(\d+)\s*[x×]\s*(\d+)\s*[x×]\s*(\d+)/);
+    if (boxM && boxDim) {
+      const w = parseInt(boxDim[1]), h = parseInt(boxDim[2]), d = parseInt(boxDim[3]);
+      return [
+        {method:'sketch.start', params:{plane:'XY'}},
+        {method:'sketch.rect', params:{width: w, height: d}},
+        {method:'ops.extrude', params:{depth: h, position:[0,0,0]}, note: w+'x'+h+'x'+d+' box'},
+        {method:'view.set', params:{view:'iso'}},
+        {method:'view.fit', params:{}}
+      ];
+    }
+        // L-bracket with holes
     if (/l-?bracket|mounting\s*bracket|angle\s*bracket/.test(p)) {
       const lenM = p.match(/(\d+)\s*mm/);
       const length = lenM ? parseInt(lenM[1]) : 100;
@@ -413,6 +511,86 @@
       plan.push({method:'view.fit', params:{}});
       return plan;
     }
+    // Spur gear (simplified — cylinder disc at OD with center bore)
+    const gearM = p.match(/\bspur\s*gear\b|\bgear\b/);
+    if (gearM) {
+      const modM = p.match(/module\s*(\d+(?:\.\d+)?)|\bm\s*=?\s*(\d+(?:\.\d+)?)\b/);
+      const teethM = p.match(/(\d+)\s*(?:teeth|tooth)|z\s*=?\s*(\d+)/);
+      const mod = modM ? parseFloat(modM[1]||modM[2]) : 2;
+      const teeth = teethM ? parseInt(teethM[1]||teethM[2]) : 20;
+      const widthM = p.match(/(\d+)\s*mm\s*(?:wide|width|face)/);
+      const width = widthM ? parseInt(widthM[1]) : 10;
+      const boreM = p.match(/(\d+)\s*mm\s*bore|bore\s*(\d+)/);
+      const bore = boreM ? parseInt(boreM[1]||boreM[2]) : 8;
+      const pitchDia = mod * teeth;
+      const outsideDia = mod * (teeth + 2);
+      return [
+        {method:'sketch.start', params:{plane:'XY'}},
+        {method:'sketch.circle', params:{radius: outsideDia/2}},
+        {method:'ops.extrude', params:{depth: width, position:[0,0,0]}, note:'spur gear blank — m='+mod+', Z='+teeth+', pitch Ø'+pitchDia+', OD Ø'+outsideDia+' (add involute teeth via Sketch tab polyline)'},
+        {method:'ops.hole', params:{position:[0, width/2, 0], radius: bore/2, depth: width+2}, note:'center bore Ø'+bore},
+        {method:'view.set', params:{view:'iso'}},
+        {method:'view.fit', params:{}}
+      ];
+    }
+    // Pulley (V-belt, simplified — disc with center bore, groove noted)
+    const pulleyM = p.match(/\bpulley\b|\bv-?belt\s*pulley\b|\btiming\s*pulley\b/);
+    if (pulleyM) {
+      const odM = p.match(/(\d+)\s*mm/);
+      const od = odM ? parseInt(odM[1]) : 80;
+      const boreM = p.match(/(\d+)\s*mm\s*bore|bore\s*(\d+)/);
+      const bore = boreM ? parseInt(boreM[1]||boreM[2]) : 12;
+      const widthM = p.match(/(\d+)\s*mm\s*(?:wide|width)/);
+      const width = widthM ? parseInt(widthM[1]) : 20;
+      return [
+        {method:'sketch.start', params:{plane:'XY'}},
+        {method:'sketch.circle', params:{radius: od/2}},
+        {method:'ops.extrude', params:{depth: width, position:[0,0,0]}, note:'pulley blank Ø'+od+'x'+width+' (add V-groove via revolve in Solid tab)'},
+        {method:'ops.hole', params:{position:[0, width/2, 0], radius: bore/2, depth: width+2}, note:'center bore Ø'+bore},
+        {method:'view.set', params:{view:'iso'}},
+        {method:'view.fit', params:{}}
+      ];
+    }
+    // Shaft (simple cylinder or stepped if "stepped" keyword)
+    const shaftM = p.match(/\bshaft\b|\baxle\b|\bspindle\b/);
+    if (shaftM) {
+      // Explicit diameter keywords first
+      const diaM = p.match(/(\d+)\s*mm\s*(?:dia|diameter)|Ø\s*(\d+)|ø\s*(\d+)/);
+      // Explicit length keywords
+      const lenM = p.match(/(\d+)\s*mm\s*(?:long|length|tall)/);
+      // Fallback: if both missing, heuristic from bare Nmm values (smaller=dia, larger=length)
+      const allMm = (p.match(/(\d+)\s*mm/g) || []).map(s => parseInt(s)).filter(n => n > 0);
+      let dia, len;
+      if (diaM) dia = parseInt(diaM[1]||diaM[2]||diaM[3]);
+      if (lenM) len = parseInt(lenM[1]);
+      if (!dia && !len && allMm.length === 2) { dia = Math.min(allMm[0], allMm[1]); len = Math.max(allMm[0], allMm[1]); }
+      else if (!dia && allMm.length >= 1) dia = allMm[0];
+      else if (!len && allMm.length >= 2) len = allMm[1];
+      dia = dia || 20; len = len || 100;
+      const stepped = /\bstepped\b|\bstep\b|\b2[- ]?step\b/.test(p);
+      if (stepped) {
+        const dia2 = Math.max(6, dia - 4);
+        const len1 = Math.round(len * 0.6);
+        const len2 = len - len1;
+        return [
+          {method:'sketch.start', params:{plane:'XY'}},
+          {method:'sketch.circle', params:{radius: dia/2}},
+          {method:'ops.extrude', params:{depth: len1, position:[0,0,0]}, note:'stepped shaft main Ø'+dia+' x '+len1+'mm'},
+          {method:'sketch.start', params:{plane:'XY'}},
+          {method:'sketch.circle', params:{radius: dia2/2}},
+          {method:'ops.extrude', params:{depth: len2, position:[0,len1,0]}, note:'stepped shaft reduced Ø'+dia2+' x '+len2+'mm'},
+          {method:'view.set', params:{view:'iso'}},
+          {method:'view.fit', params:{}}
+        ];
+      }
+      return [
+        {method:'sketch.start', params:{plane:'XY'}},
+        {method:'sketch.circle', params:{radius: dia/2}},
+        {method:'ops.extrude', params:{depth: len, position:[0,0,0]}, note:'shaft Ø'+dia+' x '+len+'mm'},
+        {method:'view.set', params:{view:'iso'}},
+        {method:'view.fit', params:{}}
+      ];
+    }
     return null;
   }
   async function run(){

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cyclecad",
-  "version": "3.10.2",
+  "version": "3.10.4",
   "description": "Browser-based parametric 3D CAD modeler with AI-powered tools, native Inventor file parsing, and smart assembly management. No install required.",
   "main": "index.html",
   "bin": {