sceneview-mcp 3.0.0 → 3.0.2

package/README.md

@@ -1,36 +1,17 @@
 # sceneview-mcp
 
-MCP server for [SceneView](https://github.com/SceneView/sceneview-android) — 3D and AR with Jetpack Compose for Android.
+[![npm](https://img.shields.io/npm/v/sceneview-mcp?color=cb3837&label=npm)](https://www.npmjs.com/package/sceneview-mcp)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
-Install this once and Claude always knows how to use SceneView. No copy-pasting docs. No hallucinated APIs.
+MCP server for [SceneView](https://github.com/SceneView/sceneview-android) — 3D and AR as Jetpack Compose composables for Android.
 
----
-
-## What it provides
-
-**Resource — `sceneview://api`**
-The complete SceneView 3.0.0 API reference (llms.txt): composable signatures, node types, AR scope, resource loading, threading rules, common patterns.
-
-**Tool — `get_sample`**
-
-| Scenario | What you get |
-|---|---|
-| `model-viewer` | Full-screen 3D scene, HDR environment, orbit camera |
-| `ar-tap-to-place` | AR tap-to-place with pinch-to-scale and drag-to-rotate |
-| `ar-placement-cursor` | AR reticle that snaps to surfaces, tap to confirm |
-| `ar-augmented-image` | Detect a reference image, overlay a 3D model |
-| `ar-face-filter` | Front-camera face mesh with a custom material |
-
-**Tool — `get_setup`**
-Gradle dependency + AndroidManifest for `"3d"` or `"ar"` projects.
+Add this to Claude and it **always knows how to use SceneView**. No copy-pasting docs. No hallucinated APIs. Correct, compilable Kotlin — first try.
 
 ---
 
-## Installation
+## Quick start
 
-### Project-level (recommended)
-
-Add `.claude/mcp.json` at your Android project root:
+Add to your Claude config and you're done:
 
 ```json
 {
@@ -43,112 +24,80 @@ Add `.claude/mcp.json` at your Android project root:
 }
 ```
 
-Run `/mcp` in Claude Code to confirm the server is connected.
+<details>
+<summary>Where does this go?</summary>
 
-### Global (all projects)
+| Client | Config file |
+|---|---|
+| **Claude Code** (project) | `.claude/mcp.json` at project root |
+| **Claude Code** (global) | `~/.claude/mcp.json` |
+| **Claude Desktop** | `claude_desktop_config.json` |
 
-Add to `~/.claude/mcp.json`:
+After saving, run `/mcp` in Claude Code or restart Claude Desktop to pick it up.
+</details>
 
-```json
-{
-  "mcpServers": {
-    "sceneview": {
-      "command": "npx",
-      "args": ["-y", "sceneview-mcp"]
-    }
-  }
-}
-```
+---
 
-### Claude Desktop
+## What Claude gets
 
-Add to `claude_desktop_config.json`:
+### Resource — `sceneview://api`
 
-```json
-{
-  "mcpServers": {
-    "sceneview": {
-      "command": "npx",
-      "args": ["-y", "sceneview-mcp"]
-    }
-  }
-}
-```
+The complete SceneView 3.0.0 API reference (`llms.txt`): composable signatures, node types, AR scope, resource loading, threading rules, and common patterns.
+
+### Tool — `get_sample(scenario)`
+
+Returns a complete, compilable Kotlin sample.
+
+| Scenario | What you get |
+|---|---|
+| `model-viewer` | Full-screen 3D scene, HDR environment, orbit camera |
+| `ar-tap-to-place` | AR tap-to-place with pinch-to-scale and drag-to-rotate |
+| `ar-placement-cursor` | AR reticle that snaps to surfaces, tap to confirm |
+| `ar-augmented-image` | Detect a reference image, overlay a 3D model |
+| `ar-face-filter` | Front-camera face mesh with a custom material |
+
+### Tool — `get_setup(type)`
+
+Returns Gradle dependencies + AndroidManifest for `"3d"` or `"ar"` projects.
 
 ---
 
 ## How it works
 
 ```
-Developer: "add AR placement to my app"
+You:    "Add AR placement to my app"
          │
-         ▼
-Claude reads sceneview://api  ←  full llms.txt, always current
+Claude:  reads sceneview://api  ←  full API ref, always current
          │
-         ▼
-Claude calls get_sample("ar-tap-to-place")  ←  working Kotlin boilerplate
+Claude:  calls get_sample("ar-tap-to-place")  ←  working Kotlin
          │
-         ▼
-Correct, compilable SceneView 3.0.0 code — first try, zero hallucination
+Result:  Correct, compilable SceneView 3.0.0 code
 ```
 
 ---
 
-## Sample prompts
+## Try it — sample prompts
 
-### 3D model viewer
-```
-Create an Android Compose screen called ModelViewerScreen that loads
-assets/models/my_model.glb in a full-screen 3D scene with orbit camera and HDR
-environment from assets/environments/sky_2k.hdr.
-Use SceneView io.github.sceneview:sceneview:3.0.0.
-```
+**3D model viewer**
+> Create a Compose screen that loads `models/helmet.glb` in a full-screen 3D scene with orbit camera and HDR environment. Use SceneView 3.0.0.
 
-### AR tap-to-place
-```
-Create an Android Compose AR screen called TapToPlaceScreen. Show a plane
-detection grid. Tapping places assets/models/chair.glb on the surface with
-pinch-to-scale and drag-to-rotate. Multiple taps = multiple objects.
-Use SceneView io.github.sceneview:arsceneview:3.0.0.
-```
+**AR tap-to-place**
+> Create an AR Compose screen. Tapping a detected surface places `models/chair.glb` with pinch-to-scale and drag-to-rotate. Multiple taps = multiple objects.
 
-### AR placement cursor
-```
-Create an AR screen called ARCursorScreen with a reticle that snaps to surfaces
-at screen center. Tap to place assets/models/object.glb and hide the reticle.
-Use SceneView io.github.sceneview:arsceneview:3.0.0.
-```
+**AR placement cursor**
+> Create an AR screen with a reticle that snaps to surfaces at screen center. Tap to place `models/object.glb` and hide the reticle.
 
-### AR augmented image
-```
-Create an AR screen called AugmentedImageScreen that detects R.drawable.target_image
-(15 cm wide) and places assets/models/overlay.glb above it scaled to image width.
-Model disappears when tracking is lost.
-Use SceneView io.github.sceneview:arsceneview:3.0.0.
-```
+**AR augmented image**
+> Create an AR screen that detects `R.drawable.target_image` (15 cm) and places `models/overlay.glb` above it, scaled to match.
 
-### AR face filter
-```
-Create an AR screen called FaceFilterScreen using the front camera that detects
-faces and applies assets/materials/face_mask.filamat to the face mesh.
-Use SceneView io.github.sceneview:arsceneview:3.0.0.
-```
+**AR face filter**
+> Create an AR screen using the front camera that detects faces and applies `materials/face_mask.filamat` to the mesh.
 
-### 3D product configurator
-```
-Create a 3D product configurator screen with Red/Blue/Green color buttons.
-Apply the selected color as a solid material on assets/models/product.glb.
-Add orbit camera and pinch-to-zoom.
-Use SceneView io.github.sceneview:sceneview:3.0.0.
-```
+**Product configurator**
+> Create a 3D product configurator with Red/Blue/Green buttons. Apply the color as a material on `models/product.glb`. Add orbit camera and pinch-to-zoom.
 
-### AR multi-object scene
-```
-Create an AR screen where a bottom sheet lets users choose between chair, table,
-and lamp GLBs in assets/models/. Tapping places the selected model. Each object
-is independently pinch-to-scale and drag-to-rotate. A "Clear all" button removes
-everything. Use SceneView io.github.sceneview:arsceneview:3.0.0.
-```
+**AR multi-object scene**
+> Create an AR screen where a bottom sheet lets users pick between chair, table, and lamp GLBs. Tap to place. Each object gets pinch-to-scale and drag-to-rotate.
 
 ---
 
@@ -157,9 +106,9 @@ everything. Use SceneView io.github.sceneview:arsceneview:3.0.0.
 ```bash
 cd mcp
 npm install
-npm run prepare   # copies ../llms.txt and compiles TypeScript
+npm run prepare   # copies llms.txt + compiles TypeScript
 npm start         # run over stdio
-npx @modelcontextprotocol/inspector node dist/index.js  # test with inspector
+npx @modelcontextprotocol/inspector node dist/index.js   # test in MCP inspector
 ```
 
 ## Publishing
@@ -169,3 +118,11 @@ cd mcp
 npm run prepare
 npm publish --access public
 ```
+
+---
+
+## Links
+
+- **SDK**: [github.com/SceneView/sceneview-android](https://github.com/SceneView/sceneview-android)
+- **npm**: [npmjs.com/package/sceneview-mcp](https://www.npmjs.com/package/sceneview-mcp)
+- **MCP spec**: [modelcontextprotocol.io](https://modelcontextprotocol.io)

package/dist/index.js

@@ -6,6 +6,9 @@ import { readFileSync } from "fs";
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 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";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 let API_DOCS;
 try {
@@ -14,7 +17,8 @@ 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.0" }, { capabilities: { resources: {}, tools: {} } });
+const server = new Server({ name: "@sceneview/mcp", version: "3.0.2" }, { capabilities: { resources: {}, tools: {} } });
+// ─── Resources ───────────────────────────────────────────────────────────────
 server.setRequestHandler(ListResourcesRequestSchema, async () => ({
     resources: [
         {
@@ -23,21 +27,36 @@ server.setRequestHandler(ListResourcesRequestSchema, async () => ({
             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.",
             mimeType: "text/markdown",
         },
+        {
+            uri: "sceneview://known-issues",
+            name: "SceneView Open GitHub Issues",
+            description: "Live list of open issues from the SceneView GitHub repository. Check this before reporting a bug or when something isn't working — there may already be a known workaround.",
+            mimeType: "text/markdown",
+        },
     ],
 }));
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    if (request.params.uri === "sceneview://api") {
-        return {
-            contents: [{ uri: "sceneview://api", mimeType: "text/markdown", text: API_DOCS }],
-        };
+    switch (request.params.uri) {
+        case "sceneview://api":
+            return {
+                contents: [{ uri: "sceneview://api", mimeType: "text/markdown", text: API_DOCS }],
+            };
+        case "sceneview://known-issues": {
+            const issues = await fetchKnownIssues();
+            return {
+                contents: [{ uri: "sceneview://known-issues", mimeType: "text/markdown", text: issues }],
+            };
+        }
+        default:
+            throw new Error(`Unknown resource: ${request.params.uri}`);
     }
-    throw new Error(`Unknown resource: ${request.params.uri}`);
 });
+// ─── Tools ───────────────────────────────────────────────────────────────────
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
         {
             name: "get_sample",
-            description: "Returns a complete, compilable Kotlin sample for a given SceneView scenario. Use this to get a working starting point before customising.",
+            description: "Returns a complete, compilable Kotlin sample for a given SceneView scenario. Use this to get a working starting point before customising. Call `list_samples` first if you are unsure which scenario fits.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -50,6 +69,20 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["scenario"],
             },
         },
+        {
+            name: "list_samples",
+            description: "Lists all available SceneView code samples with their IDs, descriptions, and tags. Use this to find the right sample before calling `get_sample`, or to show the user what SceneView can do.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tag: {
+                        type: "string",
+                        description: "Optional tag to filter by (e.g. \"ar\", \"3d\", \"anchor\", \"face-tracking\", \"geometry\", \"animation\"). Omit to list all samples.",
+                    },
+                },
+                required: [],
+            },
+        },
         {
             name: "get_setup",
             description: "Returns the Gradle dependency and AndroidManifest snippet required to use SceneView in an Android project.",
@@ -65,16 +98,46 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["type"],
             },
         },
+        {
+            name: "validate_code",
+            description: "Checks a Kotlin SceneView snippet for common mistakes: threading violations, wrong destroy order, missing null-checks on rememberModelInstance, LightNode trailing-lambda bug, deprecated 2.x APIs, and more. Always call this before presenting generated SceneView code to the user.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    code: {
+                        type: "string",
+                        description: "The Kotlin source code to validate (composable function, class, or file).",
+                    },
+                },
+                required: ["code"],
+            },
+        },
+        {
+            name: "get_migration_guide",
+            description: "Returns the full SceneView 2.x → 3.0 migration guide. Use this when a user reports code that worked in 2.x but breaks in 3.0, or when helping someone upgrade.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+        },
     ],
 }));
+// ─── Tool handlers ────────────────────────────────────────────────────────────
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     switch (request.params.name) {
+        // ── get_sample ────────────────────────────────────────────────────────────
         case "get_sample": {
             const scenario = request.params.arguments?.scenario;
             const sample = getSample(scenario);
             if (!sample) {
                 return {
-                    content: [{ type: "text", text: `Unknown scenario "${scenario}". Available: ${SAMPLE_IDS.join(", ")}` }],
+                    content: [
+                        {
+                            type: "text",
+                            text: `Unknown scenario "${scenario}". Call \`list_samples\` to see available options.`,
+                        },
+                    ],
                     isError: true,
                 };
             }
@@ -85,6 +148,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         text: [
                             `## ${sample.title}`,
                             ``,
+                            `**Tags:** ${sample.tags.join(", ")}`,
+                            ``,
                             `**Gradle dependency:**`,
                             `\`\`\`kotlin`,
                             `implementation("${sample.dependency}")`,
@@ -102,6 +167,29 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 ],
             };
         }
+        // ── list_samples ──────────────────────────────────────────────────────────
+        case "list_samples": {
+            const filterTag = request.params.arguments?.tag;
+            const entries = Object.values(SAMPLES).filter((s) => !filterTag || s.tags.includes(filterTag));
+            if (entries.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No samples found with tag "${filterTag}". Available tags: 3d, ar, model, geometry, animation, camera, environment, anchor, plane-detection, image-tracking, face-tracking, placement, gestures`,
+                        },
+                    ],
+                };
+            }
+            const header = filterTag
+                ? `## SceneView samples tagged \`${filterTag}\` (${entries.length})\n`
+                : `## All SceneView samples (${entries.length})\n`;
+            const rows = entries
+                .map((s) => `### \`${s.id}\`\n**${s.title}**\n${s.description}\n*Tags:* ${s.tags.join(", ")}\n*Dependency:* \`${s.dependency}\`\n\nCall \`get_sample("${s.id}")\` for the full code.`)
+                .join("\n\n---\n\n");
+            return { content: [{ type: "text", text: header + rows }] };
+        }
+        // ── get_setup ─────────────────────────────────────────────────────────────
         case "get_setup": {
             const type = request.params.arguments?.type;
             if (type === "3d") {
@@ -158,6 +246,23 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 isError: true,
             };
         }
+        // ── validate_code ─────────────────────────────────────────────────────────
+        case "validate_code": {
+            const code = request.params.arguments?.code;
+            if (!code || typeof code !== "string") {
+                return {
+                    content: [{ type: "text", text: "Missing required parameter: `code`" }],
+                    isError: true,
+                };
+            }
+            const issues = validateCode(code);
+            const report = formatValidationReport(issues);
+            return { content: [{ type: "text", text: report }] };
+        }
+        // ── get_migration_guide ───────────────────────────────────────────────────
+        case "get_migration_guide": {
+            return { content: [{ type: "text", text: MIGRATION_GUIDE }] };
+        }
         default:
             return {
                 content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }],

package/dist/issues.js

@@ -0,0 +1,72 @@
+// Cache for 10 minutes — avoids hammering the GitHub API on every tool call
+const CACHE_TTL_MS = 10 * 60 * 1000;
+let cache = null;
+export async function fetchKnownIssues() {
+    const now = Date.now();
+    if (cache && now - cache.fetchedAt < CACHE_TTL_MS) {
+        return cache.data;
+    }
+    let issues = [];
+    let fetchError = null;
+    try {
+        const response = await fetch("https://api.github.com/repos/SceneView/sceneview-android/issues?state=open&per_page=30", {
+            headers: {
+                Accept: "application/vnd.github+json",
+                "User-Agent": "sceneview-mcp/3.0",
+                "X-GitHub-Api-Version": "2022-11-28",
+            },
+        });
+        if (!response.ok) {
+            fetchError = `GitHub API returned ${response.status}: ${response.statusText}`;
+        }
+        else {
+            issues = (await response.json());
+        }
+    }
+    catch (err) {
+        fetchError = `Failed to fetch issues: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    const result = formatIssues(issues, fetchError);
+    cache = { data: result, fetchedAt: now };
+    return result;
+}
+function formatIssues(issues, fetchError) {
+    const lines = ["# SceneView — Open GitHub Issues\n"];
+    if (fetchError) {
+        lines.push(`> ⚠️ ${fetchError}. Showing cached data if available.\n`);
+    }
+    else {
+        lines.push(`*Fetched live from GitHub — ${issues.length} open issue(s). Cached for 10 minutes.*\n`);
+    }
+    if (issues.length === 0) {
+        lines.push("No open issues. 🎉");
+        return lines.join("\n");
+    }
+    // Group by label: bugs first, then questions/other
+    const bugs = issues.filter((i) => i.labels.some((l) => l.name === "bug"));
+    const others = issues.filter((i) => !i.labels.some((l) => l.name === "bug"));
+    const renderGroup = (title, group) => {
+        if (group.length === 0)
+            return;
+        lines.push(`## ${title}\n`);
+        for (const issue of group) {
+            const labelStr = issue.labels.length > 0 ? ` [${issue.labels.map((l) => l.name).join(", ")}]` : "";
+            lines.push(`### #${issue.number} — ${issue.title}${labelStr}`);
+            lines.push(`*Opened by @${issue.user.login} · ${issue.updated_at.slice(0, 10)}*`);
+            lines.push(issue.html_url);
+            // Include first 300 chars of body as context
+            if (issue.body) {
+                const excerpt = issue.body
+                    .replace(/\r\n/g, "\n")
+                    .replace(/```[\s\S]*?```/g, "[code block]") // strip code blocks for brevity
+                    .trim()
+                    .slice(0, 300);
+                lines.push(`\n> ${excerpt.replace(/\n/g, "\n> ")}${issue.body.length > 300 ? "…" : ""}`);
+            }
+            lines.push("");
+        }
+    };
+    renderGroup("🐛 Bug Reports", bugs);
+    renderGroup("📋 Other Issues", others);
+    return lines.join("\n");
+}

package/dist/issues.test.js

@@ -0,0 +1,114 @@
+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();
+    });
+});