makeit4me 1.0.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,14 @@
+{
+  "name": "makeit4me",
+  "version": "1.0.0",
+  "description": "MCP server and skills that give AI agents full control over SketchUp Pro",
+  "author": {
+    "name": "Lookahead Labs LLC",
+    "email": "support@makeit4me.net"
+  },
+  "homepage": "https://www.makeit4me.net",
+  "license": "proprietary",
+  "keywords": ["sketchup", "3d-modeling", "mcp", "cad"],
+  "skills": "./skills/",
+  "mcpServers": "./.mcp.json"
+}

package/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "makeit4me": {
+      "command": "node",
+      "args": ["${CLAUDE_PLUGIN_ROOT}/index.js"]
+    }
+  }
+}

package/index.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const PORT = 9876;
+const BASE = `http://127.0.0.1:${PORT}`;
+
+// ── HTTP helper ──────────────────────────────────────────────────────────────
+
+function request(method, endpoint, body) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(endpoint, BASE);
+    const payload = body ? JSON.stringify(body) : undefined;
+
+    const req = http.request(
+      {
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname,
+        method,
+        headers: {
+          ...(payload
+            ? {
+                "Content-Type": "application/json",
+                "Content-Length": Buffer.byteLength(payload),
+              }
+            : {}),
+        },
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => {
+          const text = Buffer.concat(chunks).toString();
+          try {
+            resolve(JSON.parse(text));
+          } catch {
+            resolve({ ok: false, error: `Non-JSON response: ${text.slice(0, 200)}` });
+          }
+        });
+      }
+    );
+
+    req.on("error", (err) => {
+      resolve({
+        ok: false,
+        error: `Connection failed: ${err.message}. Is SketchUp running with MakeIt4Me?`,
+      });
+    });
+
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+// ── MCP Server ───────────────────────────────────────────────────────────────
+
+const server = new McpServer({
+  name: "makeit4me",
+  version: "1.0.0",
+});
+
+// ── Tools ────────────────────────────────────────────────────────────────────
+
+server.registerTool("sketchup_status", {
+  title: "SketchUp Status",
+  description:
+    "Check if SketchUp is running and the MakeIt4Me plugin is active. " +
+    "Returns version info and active model details. Always call this first.",
+}, async () => {
+  const result = await request("GET", "/status");
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+
+server.registerTool("sketchup_models", {
+  title: "List Open Models",
+  description: "List all open SketchUp models with their titles and file paths.",
+}, async () => {
+  const result = await request("GET", "/models");
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+
+server.registerTool("sketchup_inspect", {
+  title: "Inspect Model (Read-Only)",
+  description:
+    "Evaluate Ruby code in SketchUp for read-only queries. " +
+    "The variable `model` is pre-bound to Sketchup.active_model. " +
+    "Use this for reading model state — entity counts, bounds, materials, etc. " +
+    "For geometry changes, use sketchup_operation instead.",
+  inputSchema: {
+    code: z
+      .string()
+      .describe("Ruby code to evaluate in SketchUp. `model` is pre-bound to Sketchup.active_model."),
+  },
+}, async ({ code }) => {
+  const result = await request("POST", "/inspect", { code });
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+
+server.registerTool("sketchup_operation", {
+  title: "Execute Operation (Undoable)",
+  description:
+    "Execute Ruby code wrapped in a named undo operation. " +
+    "Use for ALL geometry changes (add, move, delete) so the user can Ctrl+Z. " +
+    "The variable `model` is pre-bound to Sketchup.active_model.",
+  inputSchema: {
+    name: z
+      .string()
+      .describe("Undo label shown in Edit > Undo (e.g. 'Add front wall')"),
+    code: z
+      .string()
+      .describe("Ruby code to execute. `model` is pre-bound to Sketchup.active_model."),
+  },
+}, async ({ name, code }) => {
+  const result = await request("POST", "/operation", { name, code });
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+
+server.registerTool("sketchup_selection", {
+  title: "Manage Selection",
+  description:
+    "Read or manipulate the active selection in SketchUp. " +
+    "Actions: 'get' (list selected), 'clear', 'add' (by entity GUIDs), 'remove' (by entity GUIDs).",
+  inputSchema: {
+    action: z.enum(["get", "clear", "add", "remove"]).describe("Selection action"),
+    entities: z
+      .array(z.string())
+      .optional()
+      .describe("Entity GUIDs for add/remove actions"),
+  },
+}, async ({ action, entities }) => {
+  const body = { action };
+  if (entities) body.entities = entities;
+  const result = await request("POST", "/selection", body);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+
+server.registerTool("sketchup_screenshot", {
+  title: "Take Viewport Screenshot",
+  description:
+    "Capture a screenshot of the current SketchUp viewport. " +
+    "Optionally set the camera position first. " +
+    "Returns the image so you can visually verify geometry.",
+  inputSchema: {
+    eye: z
+      .array(z.number())
+      .length(3)
+      .optional()
+      .describe("Camera eye position [x, y, z] in inches. If omitted, uses current camera."),
+    target: z
+      .array(z.number())
+      .length(3)
+      .optional()
+      .describe("Camera target/look-at point [x, y, z] in inches."),
+    orthographic: z
+      .boolean()
+      .optional()
+      .describe("Use parallel projection (orthographic) instead of perspective. Good for elevation views."),
+    width: z.number().optional().describe("Image width in pixels (default 1920)"),
+    height: z.number().optional().describe("Image height in pixels (default 1080)"),
+  },
+}, async ({ eye, target, orthographic, width, height }) => {
+  const w = width || 1920;
+  const h = height || 1080;
+  const imgPath = path.join(os.tmpdir(), "sketchup_mcp_screenshot.png");
+
+  let code = "view = model.active_view\n";
+
+  if (eye && target) {
+    code += `eye = Geom::Point3d.new(${eye.join(", ")})\n`;
+    code += `target = Geom::Point3d.new(${target.join(", ")})\n`;
+    code += `up = Geom::Vector3d.new(0, 0, 1)\n`;
+    code += `cam = Sketchup::Camera.new(eye, target, up)\n`;
+    if (orthographic) {
+      code += `cam.perspective = false\n`;
+    }
+    code += `view.camera = cam\n`;
+  }
+
+  code += `view.write_image("${imgPath}", ${w}, ${h}, true)\n`;
+  code += `"${imgPath}"`;
+
+  const result = await request("POST", "/inspect", { code });
+
+  if (!result.ok) {
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+
+  // Read the image and return it
+  try {
+    const imgBuffer = fs.readFileSync(imgPath);
+    const base64 = imgBuffer.toString("base64");
+    return {
+      content: [
+        {
+          type: "image",
+          data: base64,
+          mimeType: "image/png",
+        },
+      ],
+    };
+  } catch (err) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Screenshot saved to ${imgPath} but failed to read: ${err.message}`,
+        },
+      ],
+    };
+  }
+});
+
+// ── Start ────────────────────────────────────────────────────────────────────
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "makeit4me",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "makeit4me": "./index.js"
+  },
+  "files": [
+    "index.js",
+    ".claude-plugin/",
+    ".mcp.json",
+    "skills/"
+  ],
+  "scripts": {
+    "start": "node index.js"
+  },
+  "author": "Lookahead Labs LLC",
+  "license": "SEE LICENSE IN LICENSE",
+  "description": "MCP server that bridges AI agents to SketchUp via the MakeIt4Me plugin",
+  "keywords": ["mcp", "sketchup", "3d-modeling", "cad", "architecture"],
+  "repository": {
+    "type": "git",
+    "url": "https://www.makeit4me.net"
+  },
+  "homepage": "https://www.makeit4me.net",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1"
+  }
+}

package/skills/sketchup-3d-warehouse-wrangling/SKILL.md

@@ -0,0 +1,221 @@
+---
+name: sketchup-3d-warehouse-wrangling
+description: |
+  Place, orient, trim, and manage 3D Warehouse components in SketchUp via the
+  Ruby API. Use when: (1) a component from the warehouse is too large or wrong
+  orientation for the model, (2) roof shingles/tiles need to be cropped to fit
+  a roof, (3) doors or windows need to be placed in wall openings, (4) components
+  need rotation for correct function (e.g., water flow direction on shingles),
+  (5) need to inspect nested component hierarchies. Covers orientation, trimming
+  by bounds, nested hierarchy navigation, and placement in openings.
+author: Claude Code
+version: 1.0.0
+date: 2026-03-11
+---
+
+# SketchUp 3D Warehouse Component Wrangling
+
+## Problem
+Components from the 3D Warehouse rarely fit your model as-is. They're often the
+wrong size, orientation, or position. Solid Tools often don't work because warehouse
+components aren't manifold solids. This skill covers practical techniques for making
+them fit.
+
+## Inspecting a Component
+
+Always start by understanding what you're working with:
+
+```ruby
+defn = model.definitions["Component Name"]
+bb = defn.bounds
+puts "W: #{bb.width.to_l}, D: #{bb.depth.to_l}, H: #{bb.height.to_l}"
+puts "Min: [#{bb.min.x.to_l}, #{bb.min.y.to_l}, #{bb.min.z.to_l}]"
+puts "Max: [#{bb.max.x.to_l}, #{bb.max.y.to_l}, #{bb.max.z.to_l}]"
+
+# Check internal structure
+counts = Hash.new(0)
+defn.entities.each { |e| counts[e.typename] += 1 }
+puts counts  # Often reveals nested ComponentInstances or Groups
+```
+
+## Navigating Nested Hierarchies
+
+Warehouse components are often deeply nested. A "roof shingles" panel might be:
+```
+ComponentInstance (panel)
+  └─ 22x ComponentInstance (rows)
+       └─ 26x Group (individual tiles)
+```
+
+To operate on leaf geometry, you must traverse:
+```ruby
+instance.definition.entities.each do |row|
+  next unless row.is_a?(Sketchup::ComponentInstance)
+  row.make_unique  # IMPORTANT: avoid modifying shared definition
+  row.definition.entities.each do |tile|
+    next unless tile.is_a?(Sketchup::Group)
+    # Now you can check bounds and delete
+  end
+end
+```
+
+## Trimming Oversized Components (Non-Solid)
+
+When Solid Tools won't work (component isn't manifold), trim by deleting
+sub-components outside your target bounds:
+
+### Step 1: Remove entire rows/sections outside bounds
+```ruby
+# Remove rows outside Y bounds (e.g., for a roof 0..144")
+instance.make_unique
+rows = instance.definition.entities.to_a.select { |e| e.is_a?(Sketchup::ComponentInstance) }
+to_del = rows.select { |r| r.bounds.min.y > 148 || r.bounds.max.y < -4 }
+instance.definition.entities.erase_entities(to_del)
+```
+
+### Step 2: Remove individual pieces within rows outside other bounds
+```ruby
+rows.each do |row|
+  row.make_unique
+  tiles = row.definition.entities.to_a.select { |e| e.is_a?(Sketchup::Group) }
+  to_del = tiles.select { |t|
+    tb = t.bounds
+    min_pt = tb.min.transform(row.transformation)
+    min_pt.x > max_x || tb.max.transform(row.transformation).x < min_x
+  }
+  row.definition.entities.erase_entities(to_del) if to_del.any?
+end
+```
+
+### Important: `make_unique` before modifying
+Without `make_unique`, modifying a definition affects ALL instances sharing it.
+Always call `make_unique` before deleting sub-geometry.
+
+## Orienting Roof Shingles for Water Flow
+
+Shingles must overlap so water runs downhill. The overlap direction depends on
+which way the component's internal rows stack.
+
+### Determine current orientation
+```ruby
+ci = model.entities.find { |e| e.is_a?(Sketchup::ComponentInstance) }
+t = ci.transformation
+puts "X axis (row direction): #{t.xaxis.to_a}"
+puts "Y axis (stacking direction): #{t.yaxis.to_a}"
+puts "Z axis (normal): #{t.zaxis.to_a}"
+```
+
+### Fix water flow direction
+If rows stack the wrong way (uphill instead of downhill), flip 180° around the
+component's local X axis, centered on the roof:
+
+```ruby
+roof_center = Geom::Point3d.new(42, 66, 96)
+flip = Geom::Transformation.rotation(roof_center, ci.transformation.xaxis, Math::PI)
+ci.transformation = flip * ci.transformation
+```
+
+### Rotate rows to run across width (not along slope)
+If shingle rows run along the slope instead of across it, rotate 90° around
+the roof surface normal:
+
+```ruby
+normal = ci.transformation.zaxis
+center = ci.bounds.center
+rot = Geom::Transformation.rotation(center, normal, 90.degrees)
+ci.transformation = rot * ci.transformation
+```
+
+**After any rotation, recenter on the roof:**
+```ruby
+roof_group = model.entities.find { |e| e.is_a?(Sketchup::Group) && e.bounds.min.z > 80 }
+rb = roof_group.bounds
+sb = ci.bounds
+move = Geom::Transformation.translation([
+  rb.center.x - sb.center.x,
+  rb.center.y - sb.center.y,
+  rb.center.z - sb.center.z
+])
+ci.transformation = move * ci.transformation
+```
+
+## Placing Doors in Wall Openings
+
+### Find the opening dimensions
+```ruby
+# Door frame group or wall opening
+frame = model.entities.find { |e|
+  e.is_a?(Sketchup::Group) && e.bounds.min.z == 0 && e.bounds.height > 70
+}
+fb = frame.bounds
+center_x = (fb.min.x + fb.max.x) / 2.0
+```
+
+### Position the door component
+```ruby
+door = model.entities.find { |e|
+  e.is_a?(Sketchup::ComponentInstance) && e.definition.name == "DoorName"
+}
+defn_bb = door.definition.bounds
+door_w = defn_bb.width
+door_d = defn_bb.depth
+
+# Center on opening, straddle the wall plane
+new_x = center_x - (door_w / 2.0)
+new_y = wall_y - (door_d / 2.0)  # center depth on wall plane
+new_z = 0.0  # or slab_z
+
+door.transformation = Geom::Transformation.new([new_x, new_y, new_z])
+```
+
+### For doors on non-front walls, rotate first
+```ruby
+# Door on right wall (X=84): rotate -90° around Z
+t_rot = Geom::Transformation.rotation(ORIGIN, Z_AXIS, -90.degrees)
+t_move = Geom::Transformation.new([wall_x, door_y, 0])
+door.transformation = t_move * t_rot
+```
+
+### Double doors (mirrored pair)
+```ruby
+# Left door: hinge at left edge, opens right
+t_rot1 = Geom::Transformation.rotation(ORIGIN, Z_AXIS, -90.degrees)
+t_move1 = Geom::Transformation.new([wall_x, opening_y_min, 0])
+door1.transformation = t_move1 * t_rot1
+
+# Right door: hinge at right edge, opens left (flip Y)
+t_rot2 = Geom::Transformation.rotation(ORIGIN, Z_AXIS, 90.degrees)
+t_move2 = Geom::Transformation.new([wall_x, opening_y_max, 0])
+door2.transformation = t_move2 * t_rot2
+
+# Shift inward by door width if they open outward
+move_in = Geom::Transformation.translation([0, door_width, 0])
+door1.transformation = move_in * door1.transformation
+```
+
+## Checking for Solid Tools Compatibility
+
+```ruby
+group.manifold?  # true = can use Solid Tools (intersect, trim, union, etc.)
+```
+
+Most warehouse components return `false`. Use the bounds-based trimming
+approach above instead.
+
+## Verification
+
+After any component manipulation:
+1. Screenshot from multiple angles
+2. Check for z-fighting (flickering surfaces)
+3. Verify bounds match expected area
+4. Check entity count hasn't exploded (common after bad explodes)
+
+## Notes
+- Scaling changes individual element sizes (bad for shingles/tiles) — trim instead
+- `explode` inside a group keeps geometry contained; explode at top level creates a mess
+- Components from the warehouse may use non-standard axes — always check `bounds` not just `origin`
+- Some components have hidden geometry — check `entities.length` vs what you see
+
+## See Also
+- `sketchup-bridge`: MCP tools and Ruby API reference
+- `sketchup-building-framing`: Generating realistic lumber framing