makeit4me 1.0.0

package/skills/sketchup-review-design/SKILL.md

@@ -0,0 +1,363 @@
+---
+name: sketchup-review-design
+description: |
+  Review a SketchUp building model like an architect or general contractor would.
+  Use when: (1) model is nearing completion and needs a quality check, (2) user
+  asks "does this look right" or "review the design", (3) checking if materials
+  are real-world purchasable (Home Depot, lumber yards), (4) verifying basic US
+  building code compliance for sheds/outbuildings, (5) looking for geometry
+  problems like mesh collisions or z-fighting, (6) generating a punch list of
+  issues to fix, (7) comparing model against a reference/goal image using Gemini
+  vision. Supports both whole-model review and section-by-section focused review.
+author: Claude Code
+version: 2.0.0
+date: 2026-03-12
+---
+
+# SketchUp Design Review
+
+Review a building model the way an architect or GC would before breaking ground.
+This skill supports two modes: **section-by-section** (preferred) and **whole-model**.
+
+---
+
+## Section-by-Section Review (Preferred)
+
+Reviewing the entire model at once produces generic, surface-level feedback.
+Instead, isolate and review one section at a time for detailed, actionable findings.
+
+### How to Review Section by Section
+
+**Step 1: Identify sections.** List the distinct areas of the model:
+```ruby
+# Get all group name prefixes to identify sections
+groups = model.entities.grep(Sketchup::Group)
+prefixes = groups.map { |g| g.name.split(" ").first(2).join(" ") }.uniq.sort
+prefixes.join("\n")
+```
+
+Typical sections for a building:
+- Foundation/slab
+- Each exterior wall (front, back, left, right)
+- Interior walls
+- Floor framing / deck
+- Roof (rafters, sheathing, ridge)
+- Turrets / towers
+- Porch / entryway
+- Balcony / deck
+- Trim and decorative elements
+- Fixtures (doors, windows, hardware)
+
+**Step 2: For each section, do a focused review cycle:**
+
+#### 2a. Isolate the section visually
+Hide everything except the section under review + its supporting structure:
+```ruby
+section_prefix = "Balcony"  # change per section
+groups = model.entities.grep(Sketchup::Group)
+
+# Hide all, show only this section + foundation
+groups.each do |g|
+  g.visible = g.name.start_with?(section_prefix) ||
+              g.name.include?("Slab") || g.name.include?("Foundation") ||
+              g.name.include?("Bot Plate")  # show what it connects to
+end
+```
+
+#### 2b. Screenshot the isolated section from multiple angles
+Position the camera close to the section, not the whole model.
+
+First, compute the section center and viewing distance via `sketchup_inspect`:
+```ruby
+section_groups = model.entities.grep(Sketchup::Group).select { |g|
+  g.name.start_with?(section_prefix)
+}
+if section_groups.any?
+  min_x = section_groups.map { |g| g.bounds.min.x }.min
+  min_y = section_groups.map { |g| g.bounds.min.y }.min
+  min_z = section_groups.map { |g| g.bounds.min.z }.min
+  max_x = section_groups.map { |g| g.bounds.max.x }.max
+  max_y = section_groups.map { |g| g.bounds.max.y }.max
+  max_z = section_groups.map { |g| g.bounds.max.z }.max
+
+  cx = (min_x + max_x) / 2.0
+  cy = (min_y + max_y) / 2.0
+  cz = (min_z + max_z) / 2.0
+  span = [max_x - min_x, max_y - min_y, max_z - min_z].max
+  dist = span * 2.5
+  "center=#{cx},#{cy},#{cz} dist=#{dist}"
+end
+```
+
+Then take screenshots from multiple angles using `sketchup_screenshot` with those computed values:
+- **Iso**: eye [cx + dist*0.6, cy - dist*0.6, cz + dist*0.4], target [cx, cy, cz]
+- **Front**: eye [cx, cy - dist, cz], target [cx, cy, cz]
+- **Side**: eye [cx + dist, cy, cz], target [cx, cy, cz]
+
+The screenshot tool returns the image directly — just view the result.
+
+#### 2c. Compare section against goal image
+Take a `sketchup_screenshot` from an angle that matches the goal image, then compare
+visually. If using the Gemini comparison script, save the screenshot first and pass
+both paths:
+```bash
+./scripts/compare_images.sh "goal_section.jpg" "/tmp/review_section.png"
+```
+
+If no cropped goal image exists, instruct Gemini to focus on just that area:
+- Modify the compare script prompt to say "Focus ONLY on the [section name] area"
+- Or take a screenshot from an angle that emphasizes the section being reviewed
+
+#### 2d. Run programmatic checks on section groups
+```ruby
+section_groups = model.entities.grep(Sketchup::Group).select { |g|
+  g.name.start_with?(section_prefix)
+}
+
+checks = []
+
+# Check for oversized lumber
+section_groups.each do |g|
+  length = [g.bounds.width, g.bounds.depth, g.bounds.height].max
+  checks << "OVERSIZED: #{g.name} (#{length.to_l})" if length > 192
+end
+
+# Check for manifold solids
+section_groups.each do |g|
+  checks << "NON-MANIFOLD: #{g.name}" if g.respond_to?(:manifold?) && !g.manifold?
+end
+
+# Check for floating pieces (not touching anything else)
+section_groups.each do |g|
+  bb = g.bounds
+  touching = section_groups.any? { |other|
+    next if other == g
+    ob = other.bounds
+    !(bb.min.x > ob.max.x + 0.5 || bb.max.x < ob.min.x - 0.5 ||
+      bb.min.y > ob.max.y + 0.5 || bb.max.y < ob.min.y - 0.5 ||
+      bb.min.z > ob.max.z + 0.5 || bb.max.z < ob.min.z - 0.5)
+  }
+  checks << "FLOATING: #{g.name} — not touching any other section piece" unless touching
+end
+
+checks.empty? ? "All checks passed" : checks.join("\n")
+```
+
+#### 2e. Record findings
+After each section review, compile:
+- What's correct
+- What's wrong (with specific fix descriptions)
+- Priority (critical / warning / cosmetic)
+
+**Step 3: Restore visibility**
+```ruby
+model.entities.grep(Sketchup::Group).each { |g| g.visible = true }
+```
+
+### Recommended Review Order
+
+Review sections in build order (bottom-up), since upper sections depend on lower:
+
+1. **Foundation / slab** — correct size, position, Z-offset
+2. **Floor framing** — joists spacing, deck coverage
+3. **Walls** (one at a time) — stud spacing, plates, headers, openings
+4. **Interior walls** — height matches roof line, door openings
+5. **Roof structure** — rafters, ridge, bearing on walls
+6. **Roof sheathing** — covers full area, no gaps
+7. **Exterior features** — porch, balcony, turrets
+8. **Trim and decorative** — fascia, shutters, star, scalloped trim
+9. **Fixtures** — doors, windows, hardware
+
+### Section Review Prompt Template
+
+When running Gemini comparison for a section, use a focused prompt:
+
+```
+Focus ONLY on the {SECTION_NAME} in both images. Ignore everything else.
+
+For the goal image: describe the {section} in detail — dimensions, lumber sizes,
+joints, spacing, materials, decorative elements.
+
+For the model image: describe the same {section} — what matches, what's different.
+
+List the top 3 specific changes needed to make the model's {section} match the goal.
+Be precise: "move X from Y to Z", "change 2x4 to 4x4", "add 6 more balusters".
+```
+
+---
+
+## Whole-Model Review (Quick Pass)
+
+Use this for a fast overall health check, not detailed design feedback.
+
+### Quick Review Script
+
+```ruby
+results = []
+bb = model.bounds
+cx = bb.center.x; cy = bb.center.y; cz = bb.center.z
+
+# Dimensions
+sqft = (bb.width * bb.depth) / 144.0
+results << "Footprint: #{sqft.round(1)} sq ft, Height: #{bb.height.to_l}"
+results << (sqft > 120 ? "NOTE: Likely needs building permit" : "May be permit-exempt")
+
+# Entity count
+counts = Hash.new(0)
+model.entities.each { |e| counts[e.typename] += 1 }
+results << "Entities: #{counts.map { |t,c| "#{t}:#{c}" }.join(", ")}"
+
+# Stray geometry
+strays = model.entities.grep(Sketchup::Edge).select { |e| e.faces.empty? }
+results << (strays.empty? ? "OK: No stray edges" : "WARNING: #{strays.length} stray edges")
+
+# Loose top-level faces
+loose = model.entities.grep(Sketchup::Face).length
+results << (loose == 0 ? "OK: No loose faces" : "WARNING: #{loose} loose faces at top level")
+
+# Oversized lumber check
+oversized = []
+model.entities.each do |e|
+  next unless e.is_a?(Sketchup::Group)
+  length = [e.bounds.width, e.bounds.depth, e.bounds.height].max
+  oversized << "#{e.name} (#{length.to_l})" if length > 192
+end
+results << (oversized.empty? ? "OK: All lumber fits standard stock" : "WARNING: Oversized: #{oversized.join(", ")}")
+
+results.join("\n")
+```
+
+### Multi-Angle Screenshots
+
+Use `./scripts/capture_views.sh <design_folder>` for standardized 10-angle capture.
+
+---
+
+## Geometry Validation Checks
+
+### Collision Detection
+```ruby
+check_collisions = lambda { |entities|
+  items = entities.to_a.select { |e|
+    e.is_a?(Sketchup::Group) || e.is_a?(Sketchup::ComponentInstance)
+  }
+  collisions = []
+  items.combination(2).each do |a, b|
+    ab = a.bounds; bb_b = b.bounds
+    next if ab.min.x > bb_b.max.x || ab.max.x < bb_b.min.x
+    next if ab.min.y > bb_b.max.y || ab.max.y < bb_b.min.y
+    next if ab.min.z > bb_b.max.z || ab.max.z < bb_b.min.z
+    a_name = a.respond_to?(:name) ? a.name : a.definition.name
+    b_name = b.respond_to?(:name) ? b.name : b.definition.name
+    collisions << "#{a_name} <-> #{b_name}"
+  end
+  collisions
+}
+```
+
+### Slab-Relative Z-Offsets
+All framing should start at slab top, not Z=0:
+```ruby
+slab = model.entities.to_a.find { |e| e.is_a?(Sketchup::Group) && e.name.include?("Slab") }
+slab_top = slab ? slab.bounds.max.z : 0
+model.entities.grep(Sketchup::Group).each do |g|
+  next if g.name.include?("Slab") || g.name.include?("Foundation")
+  if g.bounds.min.z < slab_top - 0.5 && g.bounds.min.z >= 0
+    puts "WARNING: #{g.name} starts at Z=#{g.bounds.min.z.round(1)}, slab top is Z=#{slab_top}"
+  end
+end
+```
+
+---
+
+## Structural / Framing Review
+
+### Stud Spacing (16" OC)
+```ruby
+studs = model.entities.to_a.select { |e|
+  e.is_a?(Sketchup::Group) && e.name.include?("Stud") && e.name.start_with?(wall_prefix)
+}
+positions = studs.map { |s| s.bounds.min.x }.sort  # or .min.y for Y-axis walls
+positions.each_cons(2) do |a, b|
+  spacing = b - a
+  puts "WARNING: Stud spacing #{spacing.round(1)}\"" if spacing > 16.5 || spacing < 15.5
+end
+```
+
+### Header Sizing (IRC R602.7)
+| Opening Width | Minimum Header |
+|---------------|----------------|
+| Up to 4 ft    | 2x6 |
+| 4–6 ft        | 2x8 |
+| 6–8 ft        | 2x10 |
+| 8–10 ft       | 2x12 |
+
+### Double Top Plate Check
+```ruby
+["FW", "BW", "LW", "RW", "DW"].each do |prefix|
+  plates = model.entities.to_a.select { |e|
+    e.is_a?(Sketchup::Group) && e.name.start_with?("#{prefix} Top Plate")
+  }
+  puts "WARNING: #{prefix} has #{plates.length} top plate(s), need 2" if plates.length < 2
+end
+```
+
+---
+
+## Visual Comparison with Gemini Flash
+
+### Full Model Comparison
+```bash
+./scripts/compare_images.sh "path/to/goal.jpg" /tmp/current_model.png
+```
+
+### Section-Focused Comparison
+For reviewing a specific section, modify the prompt in the compare script or
+use a focused camera angle that isolates the section being reviewed.
+
+**Best practice:** Take a close-up screenshot of the section from the same angle
+as the goal image, then compare just those two crops.
+
+---
+
+## Building Code Quick Reference (IRC)
+
+- **Under 120 sq ft**: Often permit-exempt
+- **Over 200 sq ft**: Almost always requires permit
+- **Min ceiling height**: 7ft habitable, no min for storage
+- **Min roof pitch for shingles**: 2:12 (4:12 preferred)
+- **Overhang**: 6-12" typical
+- **Setbacks**: Verify with local zoning (can't check in model)
+
+---
+
+## Output: Punch List Format
+
+```
+=== DESIGN REVIEW: {SECTION NAME} ===
+Model: [model name]
+Date: [date]
+
+## CRITICAL (must fix)
+- [ ] [issue]
+
+## WARNINGS (should fix)
+- [ ] [issue]
+
+## COSMETIC (nice to have)
+- [ ] [issue]
+
+## VERIFIED OK
+- [x] [check] ✓
+```
+
+---
+
+## References
+- [IRC Framing Inspection Checklist](https://mybuildingpermit.com/sites/default/files/documentation/Framing_0.pdf)
+- [Framing Inspection Checklist: Builder Tips](https://www.southeasterngc.com/framing-inspection-checklist/)
+
+## See Also
+- `sketchup-bridge`: MCP tools and Ruby API reference
+- `sketchup-building-framing`: Generating proper framing
+- `sketchup-model-auditing`: Automated geometry checks