sceneview-mcp 3.0.2 → 3.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sceneview-mcp",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "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",
@@ -31,7 +31,11 @@
     "sceneview-mcp": "dist/index.js"
   },
   "files": [
-    "dist",
+    "dist/index.js",
+    "dist/issues.js",
+    "dist/migration.js",
+    "dist/samples.js",
+    "dist/validator.js",
     "llms.txt"
   ],
   "engines": {

package/dist/issues.test.js

@@ -1,114 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-// We test the private formatIssues logic by calling fetchKnownIssues with a
-// mocked global fetch so we never hit the real GitHub API in tests.
-const mockIssues = [
-    {
-        number: 123,
-        title: "SIGABRT on dispose",
-        html_url: "https://github.com/SceneView/sceneview-android/issues/123",
-        body: "Calling destroy() causes a native crash.",
-        labels: [{ name: "bug" }],
-        created_at: "2026-01-01T00:00:00Z",
-        updated_at: "2026-01-15T00:00:00Z",
-        user: { login: "testuser" },
-    },
-    {
-        number: 124,
-        title: "How do I add shadows?",
-        html_url: "https://github.com/SceneView/sceneview-android/issues/124",
-        body: "I want to enable shadows for my AR scene.",
-        labels: [{ name: "question" }],
-        created_at: "2026-01-02T00:00:00Z",
-        updated_at: "2026-01-16T00:00:00Z",
-        user: { login: "anotheruser" },
-    },
-];
-beforeEach(() => {
-    // Reset module cache so the in-memory cache is cleared between tests
-    vi.resetModules();
-});
-describe("fetchKnownIssues", () => {
-    it("returns markdown with issue titles when GitHub API succeeds", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
-            ok: true,
-            json: async () => mockIssues,
-        }));
-        const { fetchKnownIssues } = await import("./issues.js");
-        const result = await fetchKnownIssues();
-        expect(result).toContain("SIGABRT on dispose");
-        expect(result).toContain("#123");
-        expect(result).toContain("How do I add shadows?");
-        expect(result).toContain("#124");
-        vi.unstubAllGlobals();
-    });
-    it("groups bug-labelled issues under Bug Reports", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
-            ok: true,
-            json: async () => mockIssues,
-        }));
-        const { fetchKnownIssues } = await import("./issues.js");
-        const result = await fetchKnownIssues();
-        expect(result).toContain("Bug Reports");
-        expect(result).toContain("SIGABRT on dispose");
-        vi.unstubAllGlobals();
-    });
-    it("groups non-bug issues under Other Issues", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
-            ok: true,
-            json: async () => mockIssues,
-        }));
-        const { fetchKnownIssues } = await import("./issues.js");
-        const result = await fetchKnownIssues();
-        expect(result).toContain("Other Issues");
-        expect(result).toContain("How do I add shadows?");
-        vi.unstubAllGlobals();
-    });
-    it("includes github URLs", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
-            ok: true,
-            json: async () => mockIssues,
-        }));
-        const { fetchKnownIssues } = await import("./issues.js");
-        const result = await fetchKnownIssues();
-        expect(result).toContain("https://github.com/SceneView/sceneview-android/issues/123");
-        vi.unstubAllGlobals();
-    });
-    it("includes body excerpt", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
-            ok: true,
-            json: async () => mockIssues,
-        }));
-        const { fetchKnownIssues } = await import("./issues.js");
-        const result = await fetchKnownIssues();
-        expect(result).toContain("native crash");
-        vi.unstubAllGlobals();
-    });
-    it("shows warning message when GitHub API fails", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
-            ok: false,
-            status: 403,
-            statusText: "Forbidden",
-        }));
-        const { fetchKnownIssues } = await import("./issues.js");
-        const result = await fetchKnownIssues();
-        expect(result).toContain("403");
-        vi.unstubAllGlobals();
-    });
-    it("shows warning message when fetch throws (network error)", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new Error("Network error")));
-        const { fetchKnownIssues } = await import("./issues.js");
-        const result = await fetchKnownIssues();
-        expect(result).toContain("Network error");
-        vi.unstubAllGlobals();
-    });
-    it("shows celebration when there are no open issues", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
-            ok: true,
-            json: async () => [],
-        }));
-        const { fetchKnownIssues } = await import("./issues.js");
-        const result = await fetchKnownIssues();
-        expect(result).toContain("No open issues");
-        vi.unstubAllGlobals();
-    });
-});

package/dist/migration.test.js

@@ -1,50 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { MIGRATION_GUIDE } from "./migration.js";
-describe("MIGRATION_GUIDE", () => {
-    it("is a non-empty string", () => {
-        expect(typeof MIGRATION_GUIDE).toBe("string");
-        expect(MIGRATION_GUIDE.length).toBeGreaterThan(500);
-    });
-    it("covers composable renames (SceneView → Scene, ArSceneView → ARScene)", () => {
-        expect(MIGRATION_GUIDE).toContain("SceneView");
-        expect(MIGRATION_GUIDE).toContain("Scene");
-        expect(MIGRATION_GUIDE).toContain("ArSceneView");
-        expect(MIGRATION_GUIDE).toContain("ARScene");
-    });
-    it("covers model loading migration (loadModelAsync → rememberModelInstance)", () => {
-        expect(MIGRATION_GUIDE).toContain("loadModelAsync");
-        expect(MIGRATION_GUIDE).toContain("rememberModelInstance");
-    });
-    it("covers removed nodes", () => {
-        expect(MIGRATION_GUIDE).toContain("TransformableNode");
-        expect(MIGRATION_GUIDE).toContain("PlacementNode");
-        expect(MIGRATION_GUIDE).toContain("ViewRenderable");
-    });
-    it("covers LightNode named apply parameter gotcha", () => {
-        expect(MIGRATION_GUIDE).toContain("apply");
-        expect(MIGRATION_GUIDE).toContain("LightNode");
-        expect(MIGRATION_GUIDE).toContain("trailing lambda");
-    });
-    it("covers engine lifecycle (rememberEngine)", () => {
-        expect(MIGRATION_GUIDE).toContain("rememberEngine");
-        expect(MIGRATION_GUIDE).toContain("engine.destroy");
-    });
-    it("covers AR anchor drift (worldPosition → AnchorNode)", () => {
-        expect(MIGRATION_GUIDE).toContain("worldPosition");
-        expect(MIGRATION_GUIDE).toContain("AnchorNode");
-        expect(MIGRATION_GUIDE).toContain("drift");
-    });
-    it("covers gradle dependency changes", () => {
-        expect(MIGRATION_GUIDE).toContain("io.github.sceneview:sceneview:3.0.0");
-        expect(MIGRATION_GUIDE).toContain("io.github.sceneview:arsceneview:3.0.0");
-    });
-    it("includes a migration checklist", () => {
-        expect(MIGRATION_GUIDE).toContain("Checklist");
-        expect(MIGRATION_GUIDE).toContain("- [ ]");
-    });
-    it("includes before/after code examples", () => {
-        expect(MIGRATION_GUIDE).toContain("Before");
-        expect(MIGRATION_GUIDE).toContain("After");
-        expect(MIGRATION_GUIDE).toContain("```kotlin");
-    });
-});

package/dist/samples.test.js

@@ -1,119 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { SAMPLES, SAMPLE_IDS, getSample } from "./samples.js";
-describe("SAMPLE_IDS", () => {
-    it("contains all 6 expected scenarios", () => {
-        expect(SAMPLE_IDS).toContain("model-viewer");
-        expect(SAMPLE_IDS).toContain("geometry-scene");
-        expect(SAMPLE_IDS).toContain("ar-tap-to-place");
-        expect(SAMPLE_IDS).toContain("ar-placement-cursor");
-        expect(SAMPLE_IDS).toContain("ar-augmented-image");
-        expect(SAMPLE_IDS).toContain("ar-face-filter");
-    });
-    it("SAMPLE_IDS matches keys of SAMPLES", () => {
-        expect(SAMPLE_IDS.sort()).toEqual(Object.keys(SAMPLES).sort());
-    });
-});
-describe("every sample", () => {
-    for (const id of SAMPLE_IDS) {
-        const sample = SAMPLES[id];
-        it(`${id}: has all required fields`, () => {
-            expect(sample.id).toBe(id);
-            expect(sample.title).toBeTruthy();
-            expect(sample.description).toBeTruthy();
-            expect(sample.tags.length).toBeGreaterThan(0);
-            expect(sample.dependency).toMatch(/^io\.github\.sceneview:/);
-            expect(sample.prompt).toBeTruthy();
-            expect(sample.code).toBeTruthy();
-        });
-        it(`${id}: code is non-empty Kotlin`, () => {
-            expect(sample.code).toContain("@Composable");
-            expect(sample.code).toContain("fun ");
-        });
-        it(`${id}: dependency is a valid sceneview artifact`, () => {
-            expect(["io.github.sceneview:sceneview:3.0.0", "io.github.sceneview:arsceneview:3.0.0"]).toContain(sample.dependency);
-        });
-    }
-});
-describe("AR samples", () => {
-    const arIds = SAMPLE_IDS.filter((id) => SAMPLES[id].tags.includes("ar"));
-    it("all AR samples use arsceneview dependency", () => {
-        for (const id of arIds) {
-            expect(SAMPLES[id].dependency).toBe("io.github.sceneview:arsceneview:3.0.0");
-        }
-    });
-    it("all AR samples contain ARScene in code", () => {
-        for (const id of arIds) {
-            expect(SAMPLES[id].code).toContain("ARScene");
-        }
-    });
-    it("all AR samples have the 'ar' tag", () => {
-        for (const id of arIds) {
-            expect(SAMPLES[id].tags).toContain("ar");
-        }
-    });
-});
-describe("3D samples", () => {
-    const d3Ids = SAMPLE_IDS.filter((id) => SAMPLES[id].tags.includes("3d"));
-    it("all 3D samples use sceneview dependency", () => {
-        for (const id of d3Ids) {
-            expect(SAMPLES[id].dependency).toBe("io.github.sceneview:sceneview:3.0.0");
-        }
-    });
-    it("all 3D samples contain Scene in code", () => {
-        for (const id of d3Ids) {
-            expect(SAMPLES[id].code).toContain("Scene(");
-        }
-    });
-});
-describe("getSample", () => {
-    it("returns the correct sample by ID", () => {
-        const s = getSample("model-viewer");
-        expect(s).toBeDefined();
-        expect(s.id).toBe("model-viewer");
-        expect(s.title).toBe("3D Model Viewer");
-    });
-    it("returns undefined for an unknown ID", () => {
-        expect(getSample("nonexistent-scenario")).toBeUndefined();
-    });
-    it("returns all samples without undefined", () => {
-        for (const id of SAMPLE_IDS) {
-            expect(getSample(id)).toBeDefined();
-        }
-    });
-});
-describe("tag filtering (simulating list_samples tool)", () => {
-    const filterByTag = (tag) => Object.values(SAMPLES).filter((s) => s.tags.includes(tag));
-    it("tag 'ar' returns only AR samples", () => {
-        const results = filterByTag("ar");
-        expect(results.length).toBeGreaterThan(0);
-        results.forEach((s) => expect(s.tags).toContain("ar"));
-    });
-    it("tag '3d' returns only 3D samples", () => {
-        const results = filterByTag("3d");
-        expect(results.length).toBeGreaterThan(0);
-        results.forEach((s) => expect(s.tags).toContain("3d"));
-    });
-    it("tag 'face-tracking' returns only the face filter sample", () => {
-        const results = filterByTag("face-tracking");
-        expect(results).toHaveLength(1);
-        expect(results[0].id).toBe("ar-face-filter");
-    });
-    it("tag 'image-tracking' returns only augmented image sample", () => {
-        const results = filterByTag("image-tracking");
-        expect(results).toHaveLength(1);
-        expect(results[0].id).toBe("ar-augmented-image");
-    });
-    it("tag 'geometry' returns only geometry scene", () => {
-        const results = filterByTag("geometry");
-        expect(results).toHaveLength(1);
-        expect(results[0].id).toBe("geometry-scene");
-    });
-    it("tag 'anchor' returns AR samples that use anchors", () => {
-        const results = filterByTag("anchor");
-        expect(results.length).toBeGreaterThan(0);
-        results.forEach((s) => expect(s.tags).toContain("anchor"));
-    });
-    it("unknown tag returns empty array", () => {
-        expect(filterByTag("nonexistent-tag")).toHaveLength(0);
-    });
-});

package/dist/validator.test.js

@@ -1,246 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { validateCode, formatValidationReport } from "./validator.js";
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-function ruleIds(code) {
-    return validateCode(code).map((i) => i.rule);
-}
-function hasRule(code, rule) {
-    return ruleIds(code).includes(rule);
-}
-// ─── threading/filament-off-main-thread ──────────────────────────────────────
-describe("threading/filament-off-main-thread", () => {
-    const RULE = "threading/filament-off-main-thread";
-    it("fires when modelLoader.createModel* used near Dispatchers.IO", () => {
-        const code = `
-      withContext(Dispatchers.IO) {
-        val model = modelLoader.createModelInstance("models/chair.glb")
-      }
-    `;
-        expect(hasRule(code, RULE)).toBe(true);
-    });
-    it("fires when Texture.Builder used near Dispatchers.Default", () => {
-        const code = `
-      launch(Dispatchers.Default) {
-        val texture = Texture.Builder().width(4).build(engine)
-      }
-    `;
-        expect(hasRule(code, RULE)).toBe(true);
-    });
-    it("does NOT fire without a background dispatcher", () => {
-        const code = `val model = modelLoader.createModelInstance("models/chair.glb")`;
-        expect(hasRule(code, RULE)).toBe(false);
-    });
-    it("does NOT fire when Dispatchers.Main is used", () => {
-        const code = `
-      withContext(Dispatchers.Main) {
-        val model = modelLoader.createModelInstance("models/chair.glb")
-      }
-    `;
-        expect(hasRule(code, RULE)).toBe(false);
-    });
-});
-// ─── ar/node-not-anchor ───────────────────────────────────────────────────────
-describe("ar/node-not-anchor", () => {
-    const RULE = "ar/node-not-anchor";
-    it("fires when worldPosition is set inside an ARScene", () => {
-        const code = `
-      ARScene(engine = engine) {
-        node.worldPosition = Position(0f, 0f, -1f)
-      }
-    `;
-        expect(hasRule(code, RULE)).toBe(true);
-    });
-    it("does NOT fire for worldPosition outside ARScene", () => {
-        const code = `node.worldPosition = Position(0f, 0f, -1f)`;
-        expect(hasRule(code, RULE)).toBe(false);
-    });
-    it("does NOT fire when AnchorNode is used correctly", () => {
-        const code = `
-      ARScene(engine = engine) {
-        AnchorNode(anchor = hitResult.createAnchor()) { }
-      }
-    `;
-        expect(hasRule(code, RULE)).toBe(false);
-    });
-});
-// ─── composable/model-instance-null-check ────────────────────────────────────
-describe("composable/model-instance-null-check", () => {
-    const RULE = "composable/model-instance-null-check";
-    it("fires when rememberModelInstance result used without null guard", () => {
-        const code = `
-      val instance = rememberModelInstance(modelLoader, "models/chair.glb")
-      ModelNode(modelInstance = instance, scaleToUnits = 1f)
-    `;
-        expect(hasRule(code, RULE)).toBe(true);
-    });
-    it("does NOT fire when guarded with ?.", () => {
-        const code = `
-      val instance = rememberModelInstance(modelLoader, "models/chair.glb")
-      instance?.let { ModelNode(modelInstance = it) }
-    `;
-        expect(hasRule(code, RULE)).toBe(false);
-    });
-    it("does NOT fire when guarded with !!", () => {
-        const code = `
-      val instance = rememberModelInstance(modelLoader, "models/chair.glb")
-      ModelNode(modelInstance = instance!!, scaleToUnits = 1f)
-    `;
-        expect(hasRule(code, RULE)).toBe(false);
-    });
-    it("does NOT fire when rememberModelInstance is not assigned to a var", () => {
-        const code = `ModelNode(modelInstance = someOtherInstance, scaleToUnits = 1f)`;
-        expect(hasRule(code, RULE)).toBe(false);
-    });
-});
-// ─── api/light-node-trailing-lambda ──────────────────────────────────────────
-describe("api/light-node-trailing-lambda", () => {
-    const RULE = "api/light-node-trailing-lambda";
-    it("fires on trailing lambda syntax", () => {
-        const code = `LightNode(engine = engine, type = LightManager.Type.SUN) { intensity(100_000f) }`;
-        expect(hasRule(code, RULE)).toBe(true);
-    });
-    it("does NOT fire when apply = { } is used correctly", () => {
-        const code = `LightNode(engine = engine, type = LightManager.Type.SUN, apply = { intensity(100_000f) })`;
-        expect(hasRule(code, RULE)).toBe(false);
-    });
-});
-// ─── lifecycle/manual-engine-create ──────────────────────────────────────────
-describe("lifecycle/manual-engine-create", () => {
-    const RULE = "lifecycle/manual-engine-create";
-    it("fires on Engine.create()", () => {
-        const code = `val engine = Engine.create(eglContext)`;
-        expect(hasRule(code, RULE)).toBe(true);
-    });
-    it("does NOT fire when rememberEngine() is used", () => {
-        const code = `val engine = rememberEngine()`;
-        expect(hasRule(code, RULE)).toBe(false);
-    });
-});
-// ─── lifecycle/manual-engine-destroy ─────────────────────────────────────────
-describe("lifecycle/manual-engine-destroy", () => {
-    const RULE = "lifecycle/manual-engine-destroy";
-    it("fires when engine.destroy() called alongside rememberEngine", () => {
-        const code = `
-      val engine = rememberEngine()
-      DisposableEffect(Unit) { onDispose { engine.destroy() } }
-    `;
-        expect(hasRule(code, RULE)).toBe(true);
-    });
-    it("does NOT fire when rememberEngine is absent (imperative code)", () => {
-        const code = `engine.destroy()`;
-        expect(hasRule(code, RULE)).toBe(false);
-    });
-});
-// ─── lifecycle/texture-destroy-order ─────────────────────────────────────────
-describe("lifecycle/texture-destroy-order", () => {
-    const RULE = "lifecycle/texture-destroy-order";
-    it("fires when texture is destroyed before material instance", () => {
-        const code = `
-      engine.safeDestroyTexture(texture)
-      materialLoader.destroyMaterialInstance(instance)
-    `;
-        expect(hasRule(code, RULE)).toBe(true);
-    });
-    it("does NOT fire when material instance destroyed first", () => {
-        const code = `
-      materialLoader.destroyMaterialInstance(instance)
-      engine.safeDestroyTexture(texture)
-    `;
-        expect(hasRule(code, RULE)).toBe(false);
-    });
-    it("does NOT fire when only one of the two is present", () => {
-        expect(hasRule(`engine.safeDestroyTexture(texture)`, RULE)).toBe(false);
-        expect(hasRule(`materialLoader.destroyMaterialInstance(instance)`, RULE)).toBe(false);
-    });
-});
-// ─── composable/prefer-remember-model-instance ────────────────────────────────
-describe("composable/prefer-remember-model-instance", () => {
-    const RULE = "composable/prefer-remember-model-instance";
-    it("fires when createModelInstance is used directly", () => {
-        const code = `val m = modelLoader.createModelInstance("models/chair.glb")`;
-        expect(hasRule(code, RULE)).toBe(true);
-    });
-    it("does NOT fire for rememberModelInstance", () => {
-        const code = `val m = rememberModelInstance(modelLoader, "models/chair.glb")`;
-        expect(hasRule(code, RULE)).toBe(false);
-    });
-});
-// ─── ar/anchor-node-missing-anchor ───────────────────────────────────────────
-describe("ar/anchor-node-missing-anchor", () => {
-    const RULE = "ar/anchor-node-missing-anchor";
-    it("fires on empty AnchorNode()", () => {
-        const code = `val node = AnchorNode()`;
-        expect(hasRule(code, RULE)).toBe(true);
-    });
-    it("does NOT fire when anchor param is provided", () => {
-        const code = `AnchorNode(anchor = hitResult.createAnchor())`;
-        expect(hasRule(code, RULE)).toBe(false);
-    });
-});
-// ─── migration/old-api ────────────────────────────────────────────────────────
-describe("migration/old-api", () => {
-    const RULE = "migration/old-api";
-    it("fires on SceneView composable", () => {
-        expect(hasRule(`SceneView(modifier = Modifier.fillMaxSize())`, RULE)).toBe(true);
-    });
-    it("fires on ArSceneView composable", () => {
-        expect(hasRule(`ArSceneView(modifier = Modifier.fillMaxSize())`, RULE)).toBe(true);
-    });
-    it("fires on TransformableNode", () => {
-        expect(hasRule(`val node = TransformableNode(system)`, RULE)).toBe(true);
-    });
-    it("fires on PlacementNode", () => {
-        expect(hasRule(`val node = PlacementNode()`, RULE)).toBe(true);
-    });
-    it("fires on ViewRenderable", () => {
-        expect(hasRule(`ViewRenderable.builder()`, RULE)).toBe(true);
-    });
-    it("fires on loadModelAsync", () => {
-        expect(hasRule(`modelLoader.loadModelAsync("models/x.glb")`, RULE)).toBe(true);
-    });
-    it("does NOT fire on modern 3.0 APIs", () => {
-        const code = `
-      val engine = rememberEngine()
-      Scene(engine = engine) {
-        rememberModelInstance(modelLoader, "models/x.glb")?.let { ModelNode(modelInstance = it) }
-      }
-    `;
-        expect(hasRule(code, RULE)).toBe(false);
-    });
-});
-// ─── api/scene-missing-engine ─────────────────────────────────────────────────
-describe("api/scene-missing-engine", () => {
-    const RULE = "api/scene-missing-engine";
-    it("fires when Scene() has no engine nearby", () => {
-        const code = `Scene(modifier = Modifier.fillMaxSize()) { }`;
-        expect(hasRule(code, RULE)).toBe(true);
-    });
-    it("does NOT fire when engine is provided", () => {
-        const code = `
-      val engine = rememberEngine()
-      Scene(modifier = Modifier.fillMaxSize(), engine = engine) { }
-    `;
-        expect(hasRule(code, RULE)).toBe(false);
-    });
-});
-// ─── formatValidationReport ───────────────────────────────────────────────────
-describe("formatValidationReport", () => {
-    it("returns success message when no issues", () => {
-        expect(formatValidationReport([])).toContain("No issues found");
-    });
-    it("includes severity counts in the header", () => {
-        const issues = validateCode(`
-      val instance = rememberModelInstance(modelLoader, "x.glb")
-      ModelNode(modelInstance = instance, scaleToUnits = 1f)
-      LightNode(engine = engine) { intensity(1f) }
-    `);
-        const report = formatValidationReport(issues);
-        expect(report).toMatch(/error/);
-        expect(report).toContain("🔴");
-    });
-    it("includes line numbers when available", () => {
-        const code = `\nval instance = rememberModelInstance(modelLoader, "x.glb")\nModelNode(modelInstance = instance, scaleToUnits = 1f)`;
-        const report = formatValidationReport(validateCode(code));
-        expect(report).toMatch(/line \d+/);
-    });
-});