makeit4me 1.0.0

package/skills/sketchup-bridge/SKILL.md

@@ -0,0 +1,255 @@
+---
+name: sketchup-bridge
+description: |
+  Control SketchUp via the makeit4me MCP server. Use when:
+  (1) sending Ruby code to SketchUp, (2) reading or modifying model
+  geometry, (3) placing/moving/deleting entities, (4) debugging Ruby eval errors
+  like scoping issues, (5) diagnosing visual artifacts like z-fighting or missing
+  geometry. Covers all MCP tools, the Ruby API cheat sheet, known gotchas, and
+  the screenshot-verify workflow.
+author: Claude Code
+version: 3.0.0
+date: 2026-03-15
+---
+
+# SketchUp Claude Bridge (MCP)
+
+SketchUp is controlled through the **makeit4me** MCP server. All tools target
+the currently active/focused model. Ruby code can be multi-line and readable —
+there is no JSON escaping or shell escaping to worry about.
+
+---
+
+## MCP Tools
+
+### `sketchup_status`
+Health check. Always call this first to confirm SketchUp is open and ready.
+
+No parameters. Returns model title, path, and SketchUp version.
+
+### `sketchup_models`
+List all open models.
+
+No parameters. Returns an array of models with title, path, and active flag.
+
+### `sketchup_inspect`
+Evaluate arbitrary Ruby in SketchUp's active model context.
+The variable `model` is pre-bound to `Sketchup.active_model`.
+
+**Parameters:** `code` (Ruby string)
+
+**Use for reads and non-destructive queries.** For geometry changes, use `sketchup_operation` so they are undoable.
+
+Example — count entities:
+```ruby
+model.entities.length
+```
+
+Example — get model bounds:
+```ruby
+model.bounds.to_s
+```
+
+### `sketchup_operation`
+Execute Ruby wrapped in a named undo operation.
+**Always use this when creating, moving, or deleting geometry** so the user can Ctrl+Z.
+
+**Parameters:** `name` (undo label), `code` (Ruby string)
+
+Ruby code can span multiple lines freely:
+```ruby
+grp = model.entities.add_group
+grp.name = "Test Box"
+ents = grp.entities
+pts = [
+  [0, 0, 0],
+  [10.inch, 0, 0],
+  [10.inch, 10.inch, 0],
+  [0, 10.inch, 0]
+]
+face = ents.add_face(pts)
+face.pushpull(5.inch)
+grp
+```
+
+### `sketchup_selection`
+Read or manipulate the active selection.
+
+**Parameters:** `action` ("get", "clear", "set", etc.), `entities` (optional, entity references)
+
+### `sketchup_screenshot`
+Take a viewport screenshot. Returns the image directly — just view the result, no need to read a temp file.
+
+**Parameters:**
+- `eye` — camera position as [x, y, z]
+- `target` — look-at point as [x, y, z]
+- `orthographic` — true for parallel projection (optional)
+- `width`, `height` — image dimensions (optional)
+
+---
+
+## Geometry Cheat Sheet (SketchUp Ruby API)
+
+```ruby
+# Units — always use .inch / .mm / .feet / .m helpers
+10.inch   # => 10 inches in SketchUp's internal unit (inches)
+2.4.m     # => 2.4 meters
+
+# Entities (top-level model geometry)
+model.entities                          # EntityCollection
+model.entities.add_face(pts)            # pts = array of [x,y,z] or Geom::Point3d
+model.entities.add_line(pt1, pt2)
+model.entities.add_box(origin, w, h, d) # returns Array of 6 faces
+model.entities.add_group                # returns Sketchup::Group
+
+# Faces
+face.pushpull(dist)                     # AVOID for boxes — direction is non-deterministic (see build-scripts skill)
+face.normal                             # Geom::Vector3d
+face.vertices.map(&:position)
+
+# Transform
+t = Geom::Transformation.translation([dx, dy, dz])
+t = Geom::Transformation.rotation(origin, axis, angle_in_radians)
+model.entities.transform_entities(t, [entity1, entity2])
+
+# Groups & Components
+grp = model.entities.add_group
+grp.name = "My Group"
+grp.entities.add_face(...)
+defn = model.definitions.add("MyComponent")
+model.entities.add_instance(defn, Geom::Transformation.new)
+
+# Materials
+mat = model.materials.add("Red")
+mat.color = Sketchup::Color.new(255, 0, 0)
+face.material = mat
+
+# Layers (Tags in newer SketchUp)
+layer = model.layers.add("Structure")
+entity.layer = layer
+```
+
+---
+
+## Known Gotchas
+
+### 1. `def` Creates Methods on Wrong Scope
+
+**Symptom**: `undefined method 'my_helper' for MakeIt4Me:Module`
+
+**Cause**: `def` inside eval creates methods on the bridge module, not as local functions.
+
+**Fix**: Use lambdas instead:
+```ruby
+# BAD - will error
+def make_box(origin, size)
+  # ...
+end
+
+# GOOD - works in eval context
+make_box = lambda { |origin, size|
+  # ...
+}
+make_box.call([0,0,0], 10)
+```
+
+### 2. Entity Deletion Race Conditions
+
+**Symptom**: `reference to deleted Entity` when iterating and deleting.
+
+**Cause**: Deleting entities while iterating invalidates references.
+
+**Fix**: Collect to array first, then batch delete:
+```ruby
+# BAD
+entities.each { |e| entities.erase_entities(e) }
+
+# GOOD
+entities.erase_entities(entities.to_a)
+
+# GOOD - with filter
+to_del = entities.to_a.select { |e| e.is_a?(Sketchup::Face) }
+entities.erase_entities(to_del) if to_del.any?
+```
+
+### 3. Materials Live on Groups, Not Always on Faces
+
+**Symptom**: `face.material` returns nil even though the geometry appears textured.
+
+**Cause**: SketchUp allows materials on groups/component instances. The group material overrides face materials visually.
+
+**Fix**: Check both levels:
+```ruby
+mat = group.material
+mat ||= group.entities.grep(Sketchup::Face).first&.material
+# Apply to group for consistency
+new_group.material = model.materials["Wall Wood"]
+```
+
+### 4. Z-Fighting Between Coplanar Faces
+
+**Symptom**: Flickering/clipping artifacts where two surfaces overlap.
+
+**Cause**: Two faces on the exact same plane. GPU can't determine draw order.
+
+**Fix**: Remove redundant coplanar geometry. Diagnose by checking overlaps:
+```ruby
+target_min = [80, 90, 0]
+target_max = [88, 120, 80]
+model.entities.each do |e|
+  bb = e.bounds
+  if bb.min.x <= target_max[0] && bb.max.x >= target_min[0] &&
+     bb.min.y <= target_max[1] && bb.max.y >= target_min[1] &&
+     bb.min.z <= target_max[2] && bb.max.z >= target_min[2]
+    puts "#{e.typename} #{e.respond_to?(:name) ? e.name : ''} overlaps"
+  end
+end
+```
+
+### 5. `add_group` from Exploded Entities
+
+**Symptom**: `All Entities must have a common parent` when re-grouping exploded entities.
+
+**Cause**: `explode` returns entities already parented to the current collection. References may be stale.
+
+**Fix**: Explode inside a group context:
+```ruby
+grp = entities.add_group
+inst = grp.entities.add_instance(defn, transform)
+inst.explode  # explodes into grp.entities, stays contained
+```
+
+---
+
+## Error Handling
+
+All MCP tools return an error field on failure with the error message and backtrace.
+Always check that the result indicates success before using the returned value.
+
+---
+
+## Workflow Pattern for Claude Code
+
+1. **Always start with `sketchup_status`** to confirm SketchUp is running.
+2. **Use `sketchup_inspect` for queries** (reading model state, inspecting geometry).
+3. **Use `sketchup_operation` for all writes** (adding/moving/deleting geometry) — makes changes undoable.
+4. **Use `sketchup_selection` to check** what the user has selected before acting on it.
+5. **Iterate small** — make one change, verify, then continue.
+6. **Screenshot-verify loop** — always visually confirm geometry changes using `sketchup_screenshot`:
+   - Set `eye` to a good vantage point for the geometry you changed
+   - Set `target` to the center of the area of interest
+   - The tool returns the image directly — just view it
+7. If the user says "undo", tell them to press Ctrl+Z in SketchUp (you can't programmatically undo via the bridge).
+
+---
+
+## Additional Notes
+
+- `Sketchup.undo` works via inspect for quick rollbacks during iteration
+- Entity indices change after any add/delete — never cache indices across operations
+- All SketchUp internal units are inches
+- Use `.to_l` for human-readable output (e.g., `84.0.to_l` → `7'`)
+
+## See Also
+- `sketchup-building-framing`: Parametric framing with real lumber dimensions
+- `sketchup-3d-warehouse-wrangling`: Placing/trimming 3D Warehouse components

package/skills/sketchup-building-model-geometry/SKILL.md

@@ -0,0 +1,134 @@
+---
+name: sketchup-building-model-geometry
+description: |
+  Build geometry in SketchUp with visual verification at every step. Use when:
+  (1) creating boxes, walls, roofs, or any 3D shapes, (2) using pushpull or
+  extrusions that can go the wrong direction, (3) assembling multiple groups
+  into a structure, (4) any geometry creation where the result needs to look
+  correct from all angles. Enforces multi-angle screenshot verification and
+  a final model audit before declaring work complete.
+author: MakeIt4Me
+version: 2.0.0
+date: 2026-03-15
+---
+
+# Building Model Geometry
+
+## The Problem
+
+When building geometry in SketchUp via the bridge, several things go wrong silently:
+
+- **pushpull goes the wrong direction** — SketchUp's `face.pushpull` direction is non-deterministic. It depends on face normal orientation, which varies based on vertex winding order. A wall that should extrude outward extrudes inward. You can't tell from a single screenshot angle.
+- **Groups clip into each other** — Two groups positioned at the same coordinates overlap. Looks fine from one angle, broken from another.
+- **Geometry lands in the wrong spot** — Off-by-one in coordinate math puts a wall 3.5" too far left. Only visible from the side or top.
+- **Faces are reversed** — The back material shows instead of the front. Invisible from most angles.
+
+All of these look correct from at least one camera angle. The fix is to never trust a single screenshot.
+
+## Rules
+
+### 1. Verify after every geometry operation
+
+After every `sketchup_operation` call that creates or moves geometry, take a screenshot with `sketchup_screenshot` and visually inspect it before moving on. Do not batch multiple operations and check once at the end.
+
+### 2. Use multiple camera angles
+
+Never verify from a single angle. After creating geometry, check from at least two of these views using `sketchup_screenshot`:
+
+**Front-right isometric** (default good starting point):
+- eye: [200, -150, 120], target: [60, 60, 40]
+
+**Back-left isometric** (catches reversed extrusions):
+- eye: [-100, 200, 120], target: [60, 60, 40]
+
+**Top-down** (catches X/Y positioning errors):
+- eye: [60, 60, 300], target: [60, 60, 0]
+
+**Front elevation** (catches Z errors, height issues):
+- eye: [60, -200, 60], target: [60, 0, 60]
+
+**Side elevation** (catches depth/Y errors):
+- eye: [-200, 60, 60], target: [0, 60, 60]
+
+Adjust the target point to center on the geometry you just created. The eye distance should be far enough to see the full context.
+
+**Tip:** Use `orthographic: true` for elevation views. It removes perspective distortion, making it easier to see which parts are in front of or behind others and to verify alignment.
+
+### 3. Fix pushpull direction immediately
+
+If a pushpull went the wrong way:
+1. Undo it (`Sketchup.undo` via `sketchup_inspect`)
+2. Reverse the face normal first, then pushpull again
+3. Or use negative distance: `face.pushpull(-distance)`
+
+```ruby
+# Check which way the normal points before pushpull
+normal = face.normal
+# If normal.z < 0 for a floor face, reverse it first
+face.reverse! if normal.z < 0
+face.pushpull(height)
+```
+
+### 4. Name every group
+
+Always name groups immediately after creation. This makes auditing and debugging possible:
+
+```ruby
+grp = model.entities.add_group
+grp.name = "Front Wall"
+```
+
+### 5. Check bounding boxes after placement
+
+After positioning a group, verify its bounds make sense:
+
+```ruby
+bb = grp.bounds
+"#{grp.name}: min=#{bb.min}, max=#{bb.max}, size=#{bb.width.to_l} x #{bb.height.to_l} x #{bb.depth.to_l}"
+```
+
+### 6. Run model audit when you think you're done
+
+Before telling the user the geometry is complete, run the `sketchup-model-auditing` checks:
+
+- Check all groups are manifold solids (`group.manifold?`)
+- Check for floating pieces (groups not resting on anything)
+- Check for mesh intersections between groups
+- Take a final multi-angle screenshot set
+
+Do not declare work complete until the audit passes or you've explained any remaining issues to the user.
+
+## Screenshot Workflow
+
+Use `sketchup_screenshot` after every geometry change. The tool returns the image directly — just view the result.
+
+**Angle 1: front-right iso**
+- eye: [200, -150, 120], target: [60, 60, 40]
+
+**Angle 2: back-left iso**
+- eye: [-100, 200, 120], target: [60, 60, 40]
+
+Then check:
+- Does the new geometry appear where expected?
+- Is the extrusion direction correct?
+- Are there any visible clipping or overlap issues?
+- Do proportions look right relative to existing geometry?
+
+## Common Pitfalls
+
+### pushpull is not deterministic
+The direction depends on face normal, which depends on vertex order. Always check the result visually. If it went wrong, undo and try `face.pushpull(-distance)` or `face.reverse!` first.
+
+### add_face vertex winding matters
+Counter-clockwise vertices (viewed from outside) produce an outward-facing normal. Clockwise produces inward. When building walls, think about which side is "outside."
+
+### Coordinate system
+SketchUp uses inches internally. X = width (left/right), Y = depth (front/back), Z = height (up/down). The origin (0,0,0) is the front-left corner at ground level.
+
+### Group transforms
+When you add geometry inside a group, coordinates are relative to the group's local origin. If you need world coordinates, use `group.transformation` to convert.
+
+## See Also
+- `sketchup-bridge`: Core MCP tools and Ruby API reference
+- `sketchup-model-auditing`: Detailed geometry and structural auditing
+- `sketchup-review-design`: Architectural review process

package/skills/sketchup-model-auditing/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: sketchup-model-auditing
+description: |
+  Programmatic geometry and structural auditing for SketchUp models via Ruby API.
+  Use when: (1) checking if framing groups are manifold solids, (2) detecting
+  floating/unsupported pieces, (3) finding mesh intersections between framing members,
+  (4) verifying sloped wall plates sit on stud tops, (5) AABB intersection checks
+  produce false positives on sloped geometry (rafters, roofs). Covers Solid Inspector 2
+  API integration, slope-aware collision detection, and structural connectivity checks.
+author: Claude Code
+version: 1.0.0
+date: 2026-03-11
+---
+
+# SketchUp Model Auditing
+
+## Problem
+SketchUp's built-in tools (Solid Inspector², CleanUp³) only check individual geometry
+validity (manifold, stray edges, reversed faces). They cannot detect:
+- Pieces floating in space with nothing supporting them
+- Mesh intersections between separate groups (studs through rafters, headers through kings)
+- Structural connectivity issues (plates not seated on studs)
+
+Additionally, naive axis-aligned bounding box (AABB) intersection checks produce massive
+false positives on sloped geometry like rafters.
+
+## Context / Trigger Conditions
+- After generating framing via build scripts
+- When the visual screenshot shows floating or intersecting pieces
+- When Solid Inspector says "all good" but the model clearly has problems
+- When AABB checks report hundreds of "intersections" that aren't real
+
+## Solution
+
+### 1. Solid Inspector 2 API (geometry-only checks)
+```ruby
+# Check manifold
+group.manifold?
+
+# Shell API for reversed/internal faces
+shell = TT::Plugins::SolidInspector2::Shell.new(group)
+shell.reversed_faces  # => array of faces
+shell.internal_faces  # => array of faces
+
+# Note: ErrorFinder.find_errors expects different args than you'd think
+# Use Shell + manifold? instead for programmatic checks
+```
+
+**What SI2 catches:** holes, stray edges, reversed faces, internal faces, non-manifold
+**What SI2 misses:** floating pieces, spatial collisions, structural connectivity
+
+### 2. Floating Piece Detection
+```ruby
+named_groups.each do |g|
+  bb = g.bounds
+  bottom_z = bb.min.z
+  next if bottom_z <= slab_top_z  # on the slab
+
+  has_support = named_groups.any? { |other|
+    next false if other == g
+    ob = other.bounds
+    # Use 1.5" tolerance for narrow contact areas (stud top to plate bottom)
+    z_touch = (ob.max.z - bottom_z).abs < 1.5
+    x_overlap = ob.min.x < (bb.max.x + 1) && ob.max.x > (bb.min.x - 1)
+    y_overlap = ob.min.y < (bb.max.y + 1) && ob.max.y > (bb.min.y - 1)
+    z_touch && x_overlap && y_overlap
+  }
+  # flag if no support found
+end
+```
+
+**Key insight:** Expand the XY overlap tolerance by ~1" for narrow members (studs/plates
+on the same wall have very small contact areas that strict AABB misses).
+
+### 3. Slope-Aware Intersection Detection (critical)
+
+**The problem:** A rafter spanning Y=-7..138 has an AABB Z range of 83..115. Every stud
+with a top Z above 83 will "intersect" the rafter's bounding box, even though the actual
+rafter geometry at that stud's Y position is well above the stud.
+
+**The fix:** Calculate the actual roof bottom Z at each entity's Y position:
+
+```ruby
+# Derive slope from actual rafter geometry
+rafters = groups.select { |g| g.name =~ /Rafter/i }
+r = rafters.first
+verts = r.entities.grep(Sketchup::Edge).flat_map { |e|
+  [e.start.position, e.end.position]
+}.uniq { |p| [p.x.round(2), p.y.round(2), p.z.round(2)] }
+
+sorted = verts.sort_by(&:y)
+front_bottom_z = sorted.first(2).map(&:z).min
+back_bottom_z = sorted.last(2).map(&:z).min
+front_y = sorted.first(2).map(&:y).min
+back_y = sorted.last(2).map(&:y).max
+
+# Lambda to get roof bottom Z at any Y
+run = back_y - front_y
+rise = front_bottom_z - back_bottom_z
+roof_bottom_z = lambda { |y|
+  t = (y - front_y) / run
+  front_bottom_z - t * rise
+}
+
+# Now check each stud against the ACTUAL roof Z at its position
+studs.each do |s|
+  center_y = (s.bounds.min.y + s.bounds.max.y) / 2.0
+  roof_z = roof_bottom_z.call(center_y)
+  if s.bounds.max.z > roof_z + 0.5  # 0.5" tolerance
+    # REAL intersection — flag it
+  end
+end
+```
+
+**Result:** Went from 196 false-positive "intersections" to 0 with this approach.
+
+### 4. Header-King Stud Overlap Check
+Headers should span between king studs, not through them. Check with volumetric overlap:
+```ruby
+headers.each do |h|
+  kings.each do |k|
+    ox = [0, [h.bounds.max.x, k.bounds.max.x].min - [h.bounds.min.x, k.bounds.min.x].max].max
+    oy = [0, [h.bounds.max.y, k.bounds.max.y].min - [h.bounds.min.y, k.bounds.min.y].max].max
+    oz = [0, [h.bounds.max.z, k.bounds.max.z].min - [h.bounds.min.z, k.bounds.min.z].max].max
+    vol = ox * oy * oz
+    # Flag if vol > 1.0 cubic inch
+  end
+end
+```
+
+### 5. Sloped Wall Plate Connectivity
+On sloped walls, top plates must sit on stud tops (gap < 0.25"):
+```ruby
+plates.each do |p|
+  stud_y = p.bounds.max.y.round(0)  # plate sits on the lower (max-Y) stud
+  stud_top = studs_by_y[stud_y]
+  gap = (p.bounds.min.z - stud_top).abs
+  # Flag if gap > 0.25"
+end
+```
+
+**Common bug:** Plates positioned one plate-thickness (1.5") too high. Caused by
+calculating plate Z as `stud_top + plate_height` instead of just `stud_top`.
+
+## Verification
+Run the complete audit by sending the audit script via `sketchup_inspect`. Since MCP
+tools accept multi-line Ruby directly, you can paste the full audit script into the
+`code` parameter. Expected output: `ALL CHECKS PASSED` with 7/7 checks green.
+
+## Notes
+- 3D Warehouse components (doors, shingles) will always fail `manifold?` — warn, don't fail
+- The floating check needs expanded XY tolerance for narrow framing members
+- Corner plate overlaps (where two walls meet) are expected — don't flag those
+- Entity indices change after any add/delete — never cache across operations
+- This audit is complementary to the visual screenshot-verify loop, not a replacement
+
+## See Also
+- `sketchup-bridge`: MCP tools and Ruby API reference
+- `sketchup-building-framing`: Parametric framing generation
+- `sketchup-review-design`: Visual/architectural review process