sceneview-mcp 3.1.1 → 3.3.0

package/dist/validator.js

@@ -196,6 +196,132 @@ const RULES = [
             return issues;
         },
     },
+    // ─── FogNode missing view parameter ──────────────────────────────────────
+    {
+        id: "api/fog-node-missing-view",
+        severity: "error",
+        check(code, lines) {
+            const issues = [];
+            if (!code.includes("FogNode"))
+                return issues;
+            const fogLines = findLines(lines, /FogNode\s*\(/);
+            fogLines.forEach((line) => {
+                const block = lines.slice(line - 1, line + 5).join("\n");
+                if (!block.includes("view")) {
+                    issues.push({
+                        severity: "error",
+                        rule: "api/fog-node-missing-view",
+                        message: "`FogNode` requires a `view` parameter — the same Filament View passed to `Scene(view = view)`. Create one with `val view = rememberView(engine)` and pass it to both `Scene` and `FogNode`.",
+                        line,
+                    });
+                }
+            });
+            return issues;
+        },
+    },
+    // ─── ReflectionProbeNode missing cameraPosition ────────────────────────
+    {
+        id: "api/reflection-probe-missing-camera",
+        severity: "warning",
+        check(code, lines) {
+            const issues = [];
+            if (!code.includes("ReflectionProbeNode"))
+                return issues;
+            const probeLines = findLines(lines, /ReflectionProbeNode\s*\(/);
+            probeLines.forEach((line) => {
+                const block = lines.slice(line - 1, line + 8).join("\n");
+                if (!block.includes("cameraPosition")) {
+                    issues.push({
+                        severity: "warning",
+                        rule: "api/reflection-probe-missing-camera",
+                        message: "`ReflectionProbeNode` needs `cameraPosition` to detect when the camera enters its zone. Track it in `onFrame`: `onFrame = { cameraPosition = cameraNode.worldPosition }` and pass it to the probe.",
+                        line,
+                    });
+                }
+            });
+            return issues;
+        },
+    },
+    // ─── PhysicsNode without radius offset ──────────────────────────────────
+    {
+        id: "api/physics-node-missing-radius",
+        severity: "info",
+        check(code, lines) {
+            const issues = [];
+            if (!code.includes("PhysicsNode"))
+                return issues;
+            const physicsLines = findLines(lines, /PhysicsNode\s*\(/);
+            physicsLines.forEach((line) => {
+                const block = lines.slice(line - 1, line + 8).join("\n");
+                if (!block.includes("radius")) {
+                    issues.push({
+                        severity: "info",
+                        rule: "api/physics-node-missing-radius",
+                        message: "`PhysicsNode` defaults to `radius = 0f` — the collision point is the node centre, not the surface. For spheres, set `radius` to match the sphere radius so the surface touches the floor.",
+                        line,
+                    });
+                }
+            });
+            return issues;
+        },
+    },
+    // ─── DynamicSkyNode outside SceneScope ──────────────────────────────────
+    {
+        id: "api/dynamic-sky-outside-scene",
+        severity: "warning",
+        check(code, lines) {
+            const issues = [];
+            if (!code.includes("DynamicSkyNode"))
+                return issues;
+            // If DynamicSkyNode appears but Scene { } doesn't, it's likely wrong
+            if (!code.includes("Scene(") && !code.includes("Scene {")) {
+                findLines(lines, /DynamicSkyNode\s*\(/).forEach((line) => issues.push({
+                    severity: "warning",
+                    rule: "api/dynamic-sky-outside-scene",
+                    message: "`DynamicSkyNode` is a `SceneScope` extension composable — it must be declared inside a `Scene { }` content block, not at the top level.",
+                    line,
+                }));
+            }
+            return issues;
+        },
+    },
+    // ─── Deprecated Sceneform imports ───────────────────────────────────────
+    {
+        id: "migration/sceneform-import",
+        severity: "error",
+        check(code, lines) {
+            const issues = [];
+            findLines(lines, /import\s+com\.google\.ar\.sceneform/).forEach((line) => issues.push({
+                severity: "error",
+                rule: "migration/sceneform-import",
+                message: "Sceneform imports detected (`com.google.ar.sceneform.*`). Sceneform was deprecated by Google in 2021. Use `io.github.sceneview.*` imports instead — SceneView is the official successor.",
+                line,
+            }));
+            return issues;
+        },
+    },
+    // ─── Node.destroy() called manually ────────────────────────────────────
+    {
+        id: "lifecycle/manual-node-destroy",
+        severity: "warning",
+        check(code, lines) {
+            const issues = [];
+            if (!code.includes("Scene(") && !code.includes("Scene {"))
+                return issues;
+            findLines(lines, /\bnode\w*\.destroy\(\)|\.\bdestroy\(\)/).forEach((line) => {
+                const lineContent = lines[line - 1];
+                if (lineContent && !lineContent.includes("engine") && !lineContent.includes("Engine")) {
+                    issues.push({
+                        severity: "warning",
+                        rule: "lifecycle/manual-node-destroy",
+                        message: "Manual `destroy()` on a node inside a composable Scene. Compose manages node lifecycle automatically — nodes are destroyed when they leave composition. Remove the manual call to avoid double-destroy crashes.",
+                        line,
+                    });
+                }
+            });
+            return issues;
+        },
+    },
     // ─── Scene missing engine param ───────────────────────────────────────────
     {
         id: "api/scene-missing-engine",
@@ -220,9 +346,167 @@ const RULES = [
         },
     },
 ];
-export function validateCode(kotlinCode) {
-    const lines = kotlinCode.split("\n");
-    return RULES.flatMap((rule) => rule.check(kotlinCode, lines));
+// ─── Swift Validation Rules ──────────────────────────────────────────────────
+const SWIFT_RULES = [
+    // ─── Missing @MainActor for async model loading ────────────────────────────
+    {
+        id: "swift/missing-main-actor",
+        severity: "warning",
+        check(code, lines) {
+            const issues = [];
+            // If there's an async function that loads models but no @MainActor annotation
+            if (/func\s+\w+.*async/.test(code) && /ModelNode\.load\(/.test(code)) {
+                if (!code.includes("@MainActor")) {
+                    findLines(lines, /func\s+\w+.*async/).forEach((line) => issues.push({
+                        severity: "warning",
+                        rule: "swift/missing-main-actor",
+                        message: "Async function that loads RealityKit models should be annotated with `@MainActor` or called from a `@MainActor` context. RealityKit entity operations are main-thread-bound. Using `.task { }` in SwiftUI is already `@MainActor`-isolated, but standalone functions should be annotated.",
+                        line,
+                    }));
+                }
+            }
+            return issues;
+        },
+    },
+    // ─── Missing async/await for ModelNode.load ────────────────────────────────
+    {
+        id: "swift/model-load-not-async",
+        severity: "error",
+        check(code, lines) {
+            const issues = [];
+            // ModelNode.load is async throws — must use try await
+            if (/ModelNode\.load\(/.test(code)) {
+                findLines(lines, /ModelNode\.load\(/).forEach((line) => {
+                    const lineContent = lines[line - 1];
+                    if (lineContent && !lineContent.includes("await") && !lineContent.includes("try")) {
+                        issues.push({
+                            severity: "error",
+                            rule: "swift/model-load-not-async",
+                            message: "`ModelNode.load()` is `async throws` — you must call it with `try await ModelNode.load(\"model.usdz\")` inside a `.task { }` block or async function.",
+                            line,
+                        });
+                    }
+                });
+            }
+            return issues;
+        },
+    },
+    // ─── Missing import statements ─────────────────────────────────────────────
+    {
+        id: "swift/missing-imports",
+        severity: "warning",
+        check(code, lines) {
+            const issues = [];
+            // Check if SceneViewSwift types are used but not imported
+            const svTypes = ["SceneView", "ARSceneView", "ModelNode", "GeometryNode", "LightNode", "TextNode", "VideoNode", "PhysicsNode", "BillboardNode", "AnchorNode", "AugmentedImageNode", "ImageNode", "CameraNode", "PathNode", "LineNode", "MeshNode", "FogNode", "DynamicSkyNode", "ReflectionProbeNode"];
+            const usesSceneView = svTypes.some((t) => code.includes(t));
+            if (usesSceneView && !code.includes("import SceneViewSwift")) {
+                issues.push({
+                    severity: "warning",
+                    rule: "swift/missing-imports",
+                    message: "SceneViewSwift types used but `import SceneViewSwift` not found. Add `import SceneViewSwift` at the top of the file.",
+                    line: 1,
+                });
+            }
+            // Check for RealityKit types without import
+            const rkTypes = ["Entity", "ModelEntity", "AnchorEntity", "RealityView", "MeshResource", "SimpleMaterial"];
+            const usesRK = rkTypes.some((t) => new RegExp(`\\b${t}\\b`).test(code));
+            if (usesRK && !code.includes("import RealityKit")) {
+                issues.push({
+                    severity: "warning",
+                    rule: "swift/missing-imports",
+                    message: "RealityKit types used but `import RealityKit` not found. Add `import RealityKit` at the top of the file.",
+                    line: 1,
+                });
+            }
+            return issues;
+        },
+    },
+    // ─── Common RealityKit mistakes: using addChild on non-Entity ──────────────
+    {
+        id: "swift/add-child-wrong-type",
+        severity: "error",
+        check(code, lines) {
+            const issues = [];
+            // Common mistake: passing ModelNode instead of ModelNode.entity
+            const patterns = [
+                [/addChild\(\s*model\s*\)/, "model"],
+                [/addChild\(\s*cube\s*\)/, "cube"],
+                [/addChild\(\s*sphere\s*\)/, "sphere"],
+                [/addChild\(\s*light\s*\)/, "light"],
+                [/addChild\(\s*text\s*\)/, "text"],
+            ];
+            for (const [pat, name] of patterns) {
+                // Only flag if the variable is likely a SceneViewSwift node wrapper, not a raw Entity
+                if (pat.test(code) && new RegExp(`(ModelNode|GeometryNode|LightNode|TextNode|VideoNode|BillboardNode).*\\b${name}\\b`).test(code)) {
+                    findLines(lines, pat).forEach((line) => issues.push({
+                        severity: "error",
+                        rule: "swift/add-child-wrong-type",
+                        message: `\`addChild(${name})\` — SceneViewSwift node wrappers are not \`Entity\` subclasses. Use \`addChild(${name}.entity)\` to add the underlying RealityKit entity.`,
+                        line,
+                    }));
+                }
+            }
+            return issues;
+        },
+    },
+    // ─── ARSceneView used on macOS or visionOS ─────────────────────────────────
+    {
+        id: "swift/ar-platform-check",
+        severity: "info",
+        check(code, lines) {
+            const issues = [];
+            if (code.includes("ARSceneView")) {
+                if (code.includes("macOS") || code.includes("visionOS")) {
+                    findLines(lines, /ARSceneView/).forEach((line) => issues.push({
+                        severity: "info",
+                        rule: "swift/ar-platform-check",
+                        message: "`ARSceneView` uses `ARView` which is only available on iOS. For macOS use `SceneView` (3D only). For visionOS, use RealityKit's `RealityView` with `ARKitSession` directly.",
+                        line,
+                    }));
+                }
+            }
+            return issues;
+        },
+    },
+    // ─── Missing error handling on model load ──────────────────────────────────
+    {
+        id: "swift/unhandled-model-load-error",
+        severity: "warning",
+        check(code, lines) {
+            const issues = [];
+            // Using try? silently swallows errors — warning but not error
+            if (/try\?\s+await\s+ModelNode\.load/.test(code)) {
+                findLines(lines, /try\?\s+await\s+ModelNode\.load/).forEach((line) => issues.push({
+                    severity: "warning",
+                    rule: "swift/unhandled-model-load-error",
+                    message: "`try?` on `ModelNode.load()` silently swallows load failures. Consider using `do { try await ... } catch { print(error) }` to at least log failures, or show a loading indicator.",
+                    line,
+                }));
+            }
+            return issues;
+        },
+    },
+];
+function detectLanguage(code) {
+    // Heuristic: if the code has Swift markers, validate as Swift
+    if (code.includes("import SwiftUI") ||
+        code.includes("import RealityKit") ||
+        code.includes("import SceneViewSwift") ||
+        code.includes("struct ") && code.includes(": View") ||
+        code.includes("@State private var") ||
+        /SceneView\s*\{.*\bin\b/.test(code)) {
+        return "swift";
+    }
+    return "kotlin";
+}
+export function validateCode(code) {
+    const lines = code.split("\n");
+    const lang = detectLanguage(code);
+    if (lang === "swift") {
+        return SWIFT_RULES.flatMap((rule) => rule.check(code, lines));
+    }
+    return RULES.flatMap((rule) => rule.check(code, lines));
 }
 export function formatValidationReport(issues) {
     if (issues.length === 0) {