sceneview-mcp 3.0.3 → 3.2.0

package/dist/index.js

@@ -9,6 +9,7 @@ import { getSample, SAMPLE_IDS, SAMPLES } from "./samples.js";
 import { validateCode, formatValidationReport } from "./validator.js";
 import { MIGRATION_GUIDE } from "./migration.js";
 import { fetchKnownIssues } from "./issues.js";
+import { parseNodeSections, findNodeSection, listNodeTypes } from "./node-reference.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 let API_DOCS;
 try {
@@ -17,14 +18,15 @@ try {
 catch {
     API_DOCS = "SceneView API docs not found. Run `npm run prepare` to bundle llms.txt.";
 }
-const server = new Server({ name: "@sceneview/mcp", version: "3.0.2" }, { capabilities: { resources: {}, tools: {} } });
+const NODE_SECTIONS = parseNodeSections(API_DOCS);
+const server = new Server({ name: "@sceneview/mcp", version: "3.2.0" }, { capabilities: { resources: {}, tools: {} } });
 // ─── Resources ───────────────────────────────────────────────────────────────
 server.setRequestHandler(ListResourcesRequestSchema, async () => ({
     resources: [
         {
             uri: "sceneview://api",
             name: "SceneView API Reference",
-            description: "Complete SceneView 3.0.0 API — Scene, ARScene, SceneScope DSL, ARSceneScope DSL, node types, resource loading, camera, gestures, math types, threading rules, and common patterns. Read this before writing any SceneView code.",
+            description: "Complete SceneView 3.1.1 API — Scene, ARScene, SceneScope DSL, ARSceneScope DSL, node types, resource loading, camera, gestures, math types, threading rules, and common patterns. Read this before writing any SceneView code.",
             mimeType: "text/markdown",
         },
         {
@@ -121,6 +123,20 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: [],
             },
         },
+        {
+            name: "get_node_reference",
+            description: "Returns the full API reference for a specific SceneView node type or composable — parameters, types, and a usage example — parsed directly from the official llms.txt. Use this when you need the exact signature or options for a node (e.g. ModelNode, LightNode, ARScene). If the requested type is not found, the response lists all available types.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    nodeType: {
+                        type: "string",
+                        description: 'The node type or composable name to look up, e.g. "ModelNode", "LightNode", "ARScene", "AnchorNode". Case-insensitive.',
+                    },
+                },
+                required: ["nodeType"],
+            },
+        },
     ],
 }));
 // ─── Tool handlers ────────────────────────────────────────────────────────────
@@ -203,7 +219,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 `### build.gradle.kts`,
                                 `\`\`\`kotlin`,
                                 `dependencies {`,
-                                `    implementation("io.github.sceneview:sceneview:3.0.0")`,
+                                `    implementation("io.github.sceneview:sceneview:3.1.1")`,
                                 `}`,
                                 `\`\`\``,
                                 ``,
@@ -224,7 +240,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 `### build.gradle.kts`,
                                 `\`\`\`kotlin`,
                                 `dependencies {`,
-                                `    implementation("io.github.sceneview:arsceneview:3.0.0")`,
+                                `    implementation("io.github.sceneview:arsceneview:3.1.1")`,
                                 `}`,
                                 `\`\`\``,
                                 ``,
@@ -263,6 +279,45 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         case "get_migration_guide": {
             return { content: [{ type: "text", text: MIGRATION_GUIDE }] };
         }
+        // ── get_node_reference ────────────────────────────────────────────────────
+        case "get_node_reference": {
+            const nodeType = request.params.arguments?.nodeType;
+            if (!nodeType || typeof nodeType !== "string") {
+                return {
+                    content: [{ type: "text", text: "Missing required parameter: `nodeType`" }],
+                    isError: true,
+                };
+            }
+            const section = findNodeSection(NODE_SECTIONS, nodeType);
+            if (!section) {
+                const available = listNodeTypes(NODE_SECTIONS).join(", ");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: [
+                                `No reference found for node type \`${nodeType}\`.`,
+                                ``,
+                                `**Available node types:**`,
+                                available,
+                            ].join("\n"),
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: [
+                            `## \`${section.name}\` — API Reference`,
+                            ``,
+                            section.content,
+                        ].join("\n"),
+                    },
+                ],
+            };
+        }
         default:
             return {
                 content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }],

package/dist/migration.js

@@ -8,8 +8,8 @@ SceneView 3.0 is a full rewrite from Android Views to **Jetpack Compose**. Nearl
 
 | 2.x | 3.0 |
 |-----|-----|
-| \`io.github.sceneview:sceneview:2.x.x\` | \`io.github.sceneview:sceneview:3.0.0\` |
-| \`io.github.sceneview:arsceneview:2.x.x\` | \`io.github.sceneview:arsceneview:3.0.0\` |
+| \`io.github.sceneview:sceneview:2.x.x\` | \`io.github.sceneview:sceneview:3.1.1\` |
+| \`io.github.sceneview:arsceneview:2.x.x\` | \`io.github.sceneview:arsceneview:3.1.1\` |
 
 ---
 

package/dist/node-reference.js

@@ -0,0 +1,73 @@
+/**
+ * node-reference.ts
+ *
+ * Parses llms.txt to extract per-node-type API reference sections.
+ * Each section starts at a `###` heading and ends just before the next `###` or `##` heading.
+ */
+// ─── Parsing ─────────────────────────────────────────────────────────────────
+/**
+ * Extract the bare node-type name from a `###` heading line.
+ * Examples:
+ *   "Scene — 3D viewport"        → "Scene"
+ *   "HitResultNode — surface cursor" → "HitResultNode"
+ *   "Primitive geometry nodes"   → "Primitive geometry nodes"
+ */
+function headingToName(heading) {
+    return heading.split(/\s*[—–-]\s*/)[0].trim();
+}
+/**
+ * Parse all `###`-level sections from the full llms.txt content.
+ * Returns a map keyed by the bare node-type name (case-insensitive lookup
+ * handled separately).
+ */
+export function parseNodeSections(llmsTxt) {
+    const sections = new Map();
+    const lines = llmsTxt.split("\n");
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line.startsWith("### ")) {
+            const headingText = line.slice(4).trim(); // text after "### "
+            const name = headingToName(headingText);
+            // Collect lines until the next `##` or `###` heading
+            const bodyLines = [line];
+            i++;
+            while (i < lines.length && !lines[i].startsWith("## ") && !lines[i].startsWith("### ")) {
+                bodyLines.push(lines[i]);
+                i++;
+            }
+            // Trim trailing blank lines
+            while (bodyLines.length > 1 && bodyLines[bodyLines.length - 1].trim() === "") {
+                bodyLines.pop();
+            }
+            sections.set(name.toLowerCase(), {
+                name,
+                heading: headingText,
+                content: bodyLines.join("\n"),
+            });
+        }
+        else {
+            i++;
+        }
+    }
+    return sections;
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Look up a node type section by name (case-insensitive).
+ *
+ * @param sections - The map returned by `parseNodeSections`
+ * @param nodeType - User-supplied name, e.g. "ModelNode", "lightnode", "ARScene"
+ * @returns The matching `NodeSection`, or `undefined` if not found.
+ */
+export function findNodeSection(sections, nodeType) {
+    return sections.get(nodeType.toLowerCase());
+}
+/**
+ * Returns a sorted array of all known node-type names.
+ */
+export function listNodeTypes(sections) {
+    return Array.from(sections.values())
+        .map((s) => s.name)
+        .sort();
+}

package/dist/samples.js

@@ -4,8 +4,8 @@ export const SAMPLES = {
         title: "3D Model Viewer",
         description: "Full-screen 3D scene with a GLB model, HDR environment, and orbit camera",
         tags: ["3d", "model", "environment", "camera"],
-        dependency: "io.github.sceneview:sceneview:3.0.0",
-        prompt: "Create an Android Compose screen called `ModelViewerScreen` that loads a GLB file from assets/models/my_model.glb and displays it in a full-screen 3D scene with an orbit camera (drag to rotate, pinch to zoom). Add an HDR environment from assets/environments/sky_2k.hdr for realistic lighting. Use SceneView `io.github.sceneview:sceneview:3.0.0`.",
+        dependency: "io.github.sceneview:sceneview:3.1.1",
+        prompt: "Create an Android Compose screen called `ModelViewerScreen` that loads a GLB file from assets/models/my_model.glb and displays it in a full-screen 3D scene with an orbit camera (drag to rotate, pinch to zoom). Add an HDR environment from assets/environments/sky_2k.hdr for realistic lighting. Use SceneView `io.github.sceneview:sceneview:3.1.1`.",
         code: `@Composable
 fun ModelViewerScreen() {
     val engine = rememberEngine()
@@ -38,8 +38,8 @@ fun ModelViewerScreen() {
         title: "3D Geometry Scene",
         description: "Procedural 3D scene using primitive geometry nodes (cube, sphere, plane) — no GLB required",
         tags: ["3d", "geometry", "animation"],
-        dependency: "io.github.sceneview:sceneview:3.0.0",
-        prompt: "Create an Android Compose screen called `GeometrySceneScreen` that renders a full-screen 3D scene with a red rotating cube, a metallic blue sphere, and a green floor plane. No model files — use SceneView built-in geometry nodes. Orbit camera. Use SceneView `io.github.sceneview:sceneview:3.0.0`.",
+        dependency: "io.github.sceneview:sceneview:3.1.1",
+        prompt: "Create an Android Compose screen called `GeometrySceneScreen` that renders a full-screen 3D scene with a red rotating cube, a metallic blue sphere, and a green floor plane. No model files — use SceneView built-in geometry nodes. Orbit camera. Use SceneView `io.github.sceneview:sceneview:3.1.1`.",
         code: `@Composable
 fun GeometrySceneScreen() {
     val engine = rememberEngine()
@@ -94,8 +94,8 @@ fun GeometrySceneScreen() {
         title: "AR Tap-to-Place",
         description: "AR scene where each tap places a GLB model on a detected surface. Placed models are pinch-to-scale and drag-to-rotate.",
         tags: ["ar", "model", "anchor", "plane-detection", "placement", "gestures"],
-        dependency: "io.github.sceneview:arsceneview:3.0.0",
-        prompt: "Create an Android Compose screen called `TapToPlaceScreen` that opens the camera in AR mode. Show a plane detection grid. When the user taps a detected surface, place a 3D GLB model from assets/models/chair.glb at that point. The user should be able to pinch-to-scale and drag-to-rotate after placing. Multiple taps = multiple objects. Use SceneView `io.github.sceneview:arsceneview:3.0.0`.",
+        dependency: "io.github.sceneview:arsceneview:3.1.1",
+        prompt: "Create an Android Compose screen called `TapToPlaceScreen` that opens the camera in AR mode. Show a plane detection grid. When the user taps a detected surface, place a 3D GLB model from assets/models/chair.glb at that point. The user should be able to pinch-to-scale and drag-to-rotate after placing. Multiple taps = multiple objects. Use SceneView `io.github.sceneview:arsceneview:3.1.1`.",
         code: `@Composable
 fun TapToPlaceScreen() {
     val engine = rememberEngine()
@@ -138,8 +138,8 @@ fun TapToPlaceScreen() {
         title: "AR Placement Cursor",
         description: "AR scene with a reticle that follows the surface at screen center. Tap to confirm placement.",
         tags: ["ar", "model", "anchor", "plane-detection", "placement", "camera"],
-        dependency: "io.github.sceneview:arsceneview:3.0.0",
-        prompt: "Create an Android Compose AR screen called `ARCursorScreen`. Show a small reticle that snaps to the nearest detected surface at the center of the screen as the user moves the camera. When the user taps, place a GLB model from assets/models/object.glb at that position and hide the reticle. Use SceneView `io.github.sceneview:arsceneview:3.0.0`.",
+        dependency: "io.github.sceneview:arsceneview:3.1.1",
+        prompt: "Create an Android Compose AR screen called `ARCursorScreen`. Show a small reticle that snaps to the nearest detected surface at the center of the screen as the user moves the camera. When the user taps, place a GLB model from assets/models/object.glb at that position and hide the reticle. Use SceneView `io.github.sceneview:arsceneview:3.1.1`.",
         code: `@Composable
 fun ARCursorScreen() {
     val engine = rememberEngine()
@@ -185,8 +185,8 @@ fun ARCursorScreen() {
         title: "AR Augmented Image",
         description: "Detects a reference image in the camera feed and overlays a 3D model above it.",
         tags: ["ar", "model", "anchor", "image-tracking"],
-        dependency: "io.github.sceneview:arsceneview:3.0.0",
-        prompt: "Create an Android Compose AR screen called `AugmentedImageScreen` that detects a printed reference image (from R.drawable.target_image, physical width 15 cm) and places a 3D GLB model from assets/models/overlay.glb above it, scaled to match the image width. The model should disappear when the image is lost. Use SceneView `io.github.sceneview:arsceneview:3.0.0`.",
+        dependency: "io.github.sceneview:arsceneview:3.1.1",
+        prompt: "Create an Android Compose AR screen called `AugmentedImageScreen` that detects a printed reference image (from R.drawable.target_image, physical width 15 cm) and places a 3D GLB model from assets/models/overlay.glb above it, scaled to match the image width. The model should disappear when the image is lost. Use SceneView `io.github.sceneview:arsceneview:3.1.1`.",
         code: `@Composable
 fun AugmentedImageScreen() {
     val engine = rememberEngine()
@@ -228,8 +228,8 @@ fun AugmentedImageScreen() {
         title: "AR Face Filter",
         description: "Front-camera AR that detects faces and renders a 3D mesh material over them.",
         tags: ["ar", "face-tracking", "camera"],
-        dependency: "io.github.sceneview:arsceneview:3.0.0",
-        prompt: "Create an Android Compose AR screen called `FaceFilterScreen` using the front camera. Detect all visible faces and apply a custom material from assets/materials/face_mask.filamat to the face mesh. Use SceneView `io.github.sceneview:arsceneview:3.0.0` with `Session.Feature.FRONT_CAMERA` and `AugmentedFaceMode.MESH3D`.",
+        dependency: "io.github.sceneview:arsceneview:3.1.1",
+        prompt: "Create an Android Compose AR screen called `FaceFilterScreen` using the front camera. Detect all visible faces and apply a custom material from assets/materials/face_mask.filamat to the face mesh. Use SceneView `io.github.sceneview:arsceneview:3.1.1` with `Session.Feature.FRONT_CAMERA` and `AugmentedFaceMode.MESH3D`.",
         code: `@Composable
 fun FaceFilterScreen() {
     val engine = rememberEngine()

package/llms.txt

@@ -2,9 +2,9 @@
 
 SceneView is a Compose-first 3D and AR SDK for Android, built on Filament (Google's real-time rendering engine) and ARCore. It provides declarative composables for rendering interactive 3D scenes, loading glTF/GLB models, and building AR experiences.
 
-**Maven artifacts (version 3.0.0):**
-- 3D only: `io.github.sceneview:sceneview:3.0.0`
-- AR + 3D: `io.github.sceneview:arsceneview:3.0.0`
+**Maven artifacts (version 3.1.1):**
+- 3D only: `io.github.sceneview:sceneview:3.1.1`
+- AR + 3D: `io.github.sceneview:arsceneview:3.1.1`
 
 **Min SDK:** 24 | **Target SDK:** 36 | **Kotlin:** 2.3.10 | **Compose BOM compatible**
 
@@ -15,8 +15,8 @@ SceneView is a Compose-first 3D and AR SDK for Android, built on Filament (Googl
 ### build.gradle (app module)
 ```kotlin
 dependencies {
-    implementation("io.github.sceneview:sceneview:3.0.0")   // 3D only
-    implementation("io.github.sceneview:arsceneview:3.0.0") // AR (includes sceneview)
+    implementation("io.github.sceneview:sceneview:3.1.1")   // 3D only
+    implementation("io.github.sceneview:arsceneview:3.1.1") // AR (includes sceneview)
 }
 ```
 
@@ -100,12 +100,31 @@ Scene(...) {
             position = Position(x = 0f, y = 0f, z = -2f),
             rotation = Rotation(y = 45f),
             isEditable = true,
-            autoAnimate = true
+            autoAnimate = true   // plays all glTF animations automatically
         )
     }
 }
 ```
 
+**Reactive animation** — drive animation selection from Compose state:
+```kotlin
+var isWalking by remember { mutableStateOf(false) }
+
+Scene(...) {
+    instance?.let {
+        ModelNode(
+            modelInstance = it,
+            autoAnimate = false,
+            animationName = if (isWalking) "Walk" else "Idle",
+            animationLoop = true,
+            animationSpeed = 1f
+        )
+    }
+}
+// When animationName changes, the previous animation stops and the new one starts.
+// animationName = null + autoAnimate = true plays all animations.
+```
+
 ### Primitive geometry nodes
 ```kotlin
 Scene(...) {
@@ -144,6 +163,28 @@ Scene(...) {
 }
 ```
 
+### VideoNode — video on a 3D plane
+```kotlin
+val player = remember {
+    MediaPlayer().apply {
+        setDataSource(context, videoUri)
+        isLooping = true
+        prepare()
+        start()
+    }
+}
+DisposableEffect(Unit) { onDispose { player.release() } }
+
+Scene(...) {
+    VideoNode(
+        player = player,
+        // size = null → auto-sized from video aspect ratio (longer edge = 1 unit)
+        position = Position(z = -2f)
+    )
+}
+```
+Supports `chromaKeyColor: Int?` for green-screen compositing.
+
 ### ViewNode — Compose UI in 3D
 ```kotlin
 val windowManager = rememberViewNodeManager()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sceneview-mcp",
-  "version": "3.0.3",
+  "version": "3.2.0",
   "description": "MCP server for SceneView — 3D and AR with Jetpack Compose for Android. Give Claude the full SceneView SDK so it writes correct, compilable Kotlin.",
   "keywords": [
     "mcp",
@@ -34,6 +34,7 @@
     "dist/index.js",
     "dist/issues.js",
     "dist/migration.js",
+    "dist/node-reference.js",
     "dist/samples.js",
     "dist/validator.js",
     "llms.txt"