@assistant-ui/mcp-docs-server 0.1.38 → 0.1.39

package/src/tools/tests/mcp-protocol.test.ts

@@ -4,9 +4,13 @@ import {
   InitializeRequestSchema,
   ListToolsRequestSchema,
   CallToolRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema,
   type InitializeRequest,
   type ListToolsRequest,
   type CallToolRequest,
+  type ListPromptsRequest,
+  type GetPromptRequest,
 } from "@modelcontextprotocol/sdk/types.js";
 
 describe("MCP Protocol Integration", () => {
@@ -55,7 +59,7 @@ describe("MCP Protocol Integration", () => {
 
     expect(result).toBeDefined();
     expect(result.tools).toBeInstanceOf(Array);
-    expect(result.tools).toHaveLength(3);
+    expect(result.tools).toHaveLength(6);
 
     // Check the tools have proper JSON schemas
     const docsTool = result.tools.find(
@@ -93,6 +97,30 @@ describe("MCP Protocol Integration", () => {
     expect(searchTool.title).toBe("Search assistant-ui Documentation");
     expect(searchTool.annotations?.readOnlyHint).toBe(true);
     expect(searchTool.annotations?.openWorldHint).toBe(false);
+
+    const xuluxListTool = result.tools.find(
+      (t: any) => t.name === "assistantUITemplates",
+    );
+    expect(xuluxListTool).toBeDefined();
+    expect(xuluxListTool.title).toBe("assistant-ui Templates");
+    expect(xuluxListTool.annotations?.readOnlyHint).toBe(true);
+    expect(xuluxListTool.annotations?.openWorldHint).toBe(true);
+
+    const xuluxDetailsTool = result.tools.find(
+      (t: any) => t.name === "assistantUITemplateDetails",
+    );
+    expect(xuluxDetailsTool).toBeDefined();
+    expect(xuluxDetailsTool.title).toBe("assistant-ui Template Details");
+    expect(xuluxDetailsTool.annotations?.readOnlyHint).toBe(true);
+    expect(xuluxDetailsTool.annotations?.openWorldHint).toBe(true);
+
+    const xuluxPreviewTool = result.tools.find(
+      (t: any) => t.name === "assistantUITemplatePreview",
+    );
+    expect(xuluxPreviewTool).toBeDefined();
+    expect(xuluxPreviewTool.title).toBe("assistant-ui Template Preview URLs");
+    expect(xuluxPreviewTool.annotations?.readOnlyHint).toBe(false);
+    expect(xuluxPreviewTool.annotations?.openWorldHint).toBe(true);
   });
 
   it("should handle CallTool request for assistantUIDocs", async () => {
@@ -148,4 +176,56 @@ describe("MCP Protocol Integration", () => {
     expect(result.content).toBeDefined();
     expect(result.content[0].type).toBe("text");
   });
+
+  it("should handle ListPrompts request", async () => {
+    const request: ListPromptsRequest = {
+      method: "prompts/list",
+      params: {},
+    };
+
+    const parsed = ListPromptsRequestSchema.parse(request);
+    expect(parsed).toBeDefined();
+
+    const handlers = (server as any).server._requestHandlers;
+    expect(handlers.get("prompts/list")).toBeDefined();
+
+    const handler = handlers.get("prompts/list");
+    const result = await handler(parsed, {});
+
+    expect(result.prompts).toBeInstanceOf(Array);
+    const prompt = result.prompts.find(
+      (p: any) => p.name === "assistant-ui-template-workflow",
+    );
+    expect(prompt).toBeDefined();
+    expect(prompt.title).toBe("assistant-ui Template Workflow");
+  });
+
+  it("should handle GetPrompt request for assistant-ui-template-workflow", async () => {
+    const request: GetPromptRequest = {
+      method: "prompts/get",
+      params: {
+        name: "assistant-ui-template-workflow",
+        arguments: {},
+      },
+    };
+
+    const parsed = GetPromptRequestSchema.parse(request);
+    expect(parsed).toBeDefined();
+
+    const handlers = (server as any).server._requestHandlers;
+    expect(handlers.get("prompts/get")).toBeDefined();
+
+    const handler = handlers.get("prompts/get");
+    const result = await handler(parsed, {});
+
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0].content.type).toBe("text");
+    expect(result.messages[0].content.text).toContain("assistantUITemplates");
+    expect(result.messages[0].content.text).toContain(
+      "assistantUITemplateDetails",
+    );
+    expect(result.messages[0].content.text).toContain(
+      "assistantUITemplatePreview",
+    );
+  });
 });

package/src/tools/tests/test-setup.ts

@@ -5,11 +5,19 @@ import { PACKAGE_DIR } from "../../constants.js";
 import { docsTools } from "../docs.js";
 import { examplesTools } from "../examples.js";
 import { searchTools } from "../search.js";
+import {
+  xuluxTemplatesListTool,
+  xuluxTemplateDetailsTool,
+  xuluxTemplatePreviewTool,
+} from "../xulux-templates.js";
 
 const tools = {
   assistantUIDocs: docsTools,
   assistantUIExamples: examplesTools,
   assistantUISearch: searchTools,
+  assistantUITemplates: xuluxTemplatesListTool,
+  assistantUITemplateDetails: xuluxTemplateDetailsTool,
+  assistantUITemplatePreview: xuluxTemplatePreviewTool,
 };
 
 export const testContext = {

package/src/tools/tests/xulux-templates.test.ts

@@ -0,0 +1,262 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { clearCatalogCache } from "../../xulux/catalog-client.js";
+import {
+  xuluxTemplatesListTool,
+  xuluxTemplateDetailsTool,
+  xuluxTemplatePreviewTool,
+} from "../xulux-templates.js";
+
+const LIVE_CATALOG = {
+  version: 1,
+  generatedAt: "2026-07-10T00:00:00.000Z",
+  docsOrigin: "https://www.assistant-ui.com",
+  templates: [
+    {
+      id: "base-assistant-ui",
+      templateId: "base-assistant-ui",
+      versionId: "default",
+      kind: "template",
+      name: "Configurable Base Assistant UI",
+      summary: "Base chat template",
+      assistantPlacement: "full-page chat shell",
+      features: ["threads", "composer"],
+      customizable: ["assistant", "brandTheme"],
+      versions: [
+        {
+          id: "default",
+          entryId: "base-assistant-ui-default",
+          name: "Default",
+          description: "Default base chat",
+          previewUrl: "https://base.example.com",
+          downloadUrl: "https://base.example.com/api/download",
+        },
+      ],
+      previewUrl: "https://base.example.com",
+      downloadUrl: "https://base.example.com/api/download",
+      sandboxBaseUrl: "https://base.example.com",
+      configRoots: {
+        assistant: { description: "Assistant config" },
+      },
+      rules: {
+        required: ["Only pass documented top-level config roots."],
+      },
+      tools: {
+        builtIn: [{ id: "getWeather" }],
+        customToolSupported: true,
+        renderers: [{ type: "generic" }],
+      },
+    },
+    {
+      id: "base",
+      templateId: "base",
+      versionId: null,
+      kind: "example",
+      name: "Base Demo",
+      summary: "Fixed base demo",
+      assistantPlacement: "full-page demo route",
+      features: ["fixed demo"],
+      customizable: [],
+      versions: [],
+      previewUrl: "https://www.assistant-ui.com/demos/base",
+      downloadUrl:
+        "https://www.assistant-ui.com/api/xulux/demo-download?slug=base",
+      rules: {
+        required: [
+          "This entry is a fixed demo and is not schema-customizable.",
+        ],
+      },
+    },
+  ],
+};
+
+function jsonResponse(body: unknown, init?: ResponseInit) {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+    ...init,
+  });
+}
+
+async function callTool(
+  tool:
+    | typeof xuluxTemplatesListTool
+    | typeof xuluxTemplateDetailsTool
+    | typeof xuluxTemplatePreviewTool,
+  args: unknown,
+) {
+  const result = await tool.execute(args as never);
+  const text = result.content?.[0]?.text;
+  if (!text) throw new Error(`Tool ${tool.name} returned no text content`);
+  return JSON.parse(text);
+}
+
+describe("assistant-ui template MCP tools", () => {
+  beforeEach(() => {
+    clearCatalogCache();
+    vi.stubEnv("XULUX_CATALOG_URL", "https://catalog.example.com/mcp-catalog");
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    vi.unstubAllGlobals();
+    clearCatalogCache();
+  });
+
+  it("lists templates from the live catalog", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => jsonResponse(LIVE_CATALOG)),
+    );
+
+    const result = await callTool(xuluxTemplatesListTool, {});
+    expect(result.catalogDegraded).toBeUndefined();
+    expect(result.templates).toHaveLength(2);
+    expect(result.templates[0]).toMatchObject({
+      id: "base-assistant-ui",
+      kind: "template",
+      name: "Configurable Base Assistant UI",
+    });
+  });
+
+  it("uses the minimal fallback catalog when the live catalog is unavailable", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => {
+        throw new Error("network unavailable");
+      }),
+    );
+
+    const result = await callTool(xuluxTemplatesListTool, {});
+    expect(result.catalogDegraded).toBe(true);
+    expect(result.catalogDegradedReason).toContain("network unavailable");
+    expect(result.templates.map((t: any) => t.id)).toContain(
+      "base-assistant-ui",
+    );
+  });
+
+  it("returns details and fetches exampleConfig from the selected sandbox contract", async () => {
+    const fetchMock = vi.fn(async (url: string | URL) => {
+      const href = String(url);
+      if (href === "https://catalog.example.com/mcp-catalog") {
+        return jsonResponse(LIVE_CATALOG);
+      }
+      if (href === "https://base.example.com/api/template/contract?v=default") {
+        return jsonResponse({
+          exampleCompleteConfig: {
+            assistant: { appName: "Example" },
+          },
+        });
+      }
+      throw new Error(`Unexpected fetch: ${href}`);
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const result = await callTool(xuluxTemplateDetailsTool, {
+      templateId: "base-assistant-ui",
+      versionId: "default",
+    });
+    expect(result.selectedVersionId).toBe("default");
+    expect(result.configRoots.assistant).toBeDefined();
+    expect(result.exampleConfig).toEqual({
+      assistant: { appName: "Example" },
+    });
+    expect(fetchMock).toHaveBeenCalledWith(
+      "https://base.example.com/api/template/contract?v=default",
+      expect.objectContaining({
+        cache: "no-store",
+        headers: expect.any(Headers),
+      }),
+    );
+    const sandboxCall = fetchMock.mock.calls.find((call) =>
+      String(call[0]).includes("/api/template/contract"),
+    ) as [string | URL, RequestInit] | undefined;
+    expect(sandboxCall?.[1].headers).toBeInstanceOf(Headers);
+    expect((sandboxCall?.[1].headers as Headers).get("User-Agent")).toBe(
+      "curl/8.7.1",
+    );
+  });
+
+  it("returns fixed demo preview URLs and rejects config for fixed demos", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => jsonResponse(LIVE_CATALOG)),
+    );
+
+    const ok = await callTool(xuluxTemplatePreviewTool, {
+      templateId: "base",
+    });
+    expect(ok).toMatchObject({
+      success: true,
+      templateId: "base",
+      previewUrl: "https://www.assistant-ui.com/demos/base",
+      customized: false,
+    });
+
+    const rejected = await callTool(xuluxTemplatePreviewTool, {
+      templateId: "base",
+      config: { assistant: { appName: "Nope" } },
+    });
+    expect(rejected.success).toBe(false);
+    expect(rejected.error).toContain("fixed demo");
+  });
+
+  it("creates configured hosted previews through the sandbox session endpoint", async () => {
+    const fetchMock = vi.fn(async (url: string | URL, init?: RequestInit) => {
+      const href = String(url);
+      if (href === "https://catalog.example.com/mcp-catalog") {
+        return jsonResponse(LIVE_CATALOG);
+      }
+      if (href === "https://base.example.com/api/preview/session?v=default") {
+        expect(init?.method).toBe("POST");
+        expect(init?.body).toBe(
+          JSON.stringify({ assistant: { appName: "Custom" } }),
+        );
+        return jsonResponse({
+          previewUrl: "/preview/session-1",
+          downloadUrl: "/api/download?session=1",
+          validationWarnings: [],
+        });
+      }
+      throw new Error(`Unexpected fetch: ${href}`);
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const result = await callTool(xuluxTemplatePreviewTool, {
+      templateId: "base-assistant-ui-default",
+      config: { assistant: { appName: "Custom" } },
+    });
+    expect(result).toMatchObject({
+      success: true,
+      templateId: "base-assistant-ui",
+      versionId: "default",
+      previewUrl: "https://base.example.com/preview/session-1?v=default",
+      downloadUrl: "https://base.example.com/api/download?session=1&v=default",
+      customized: true,
+    });
+  });
+
+  it("matches the web tool shape for configured preview network failures", async () => {
+    const fetchMock = vi.fn(async (url: string | URL) => {
+      const href = String(url);
+      if (href === "https://catalog.example.com/mcp-catalog") {
+        return jsonResponse(LIVE_CATALOG);
+      }
+      if (href === "https://base.example.com/api/preview/session?v=default") {
+        throw new Error("fetch failed");
+      }
+      throw new Error(`Unexpected fetch: ${href}`);
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const result = await callTool(xuluxTemplatePreviewTool, {
+      templateId: "base-assistant-ui",
+      config: { assistant: { appName: "Custom" } },
+    });
+    expect(result).toEqual({
+      success: false,
+      templateId: "base-assistant-ui",
+      versionId: "default",
+      error: "fetch failed",
+    });
+  });
+});

package/src/tools/xulux-templates.ts

@@ -0,0 +1,141 @@
+import { z } from "zod/v3";
+import { logger } from "../utils/logger.js";
+import { formatMCPResponse } from "../utils/mcp-format.js";
+import { getXuluxCatalog } from "../xulux/catalog-client.js";
+import {
+  createTemplatePreview,
+  getTemplateDetails,
+  listTemplates,
+} from "../xulux/template-service.js";
+
+const emptyInputSchema = z.object({});
+
+const detailsInputSchema = z.object({
+  templateId: z.string().describe("The template id from assistantUITemplates"),
+  versionId: z
+    .string()
+    .optional()
+    .describe(
+      "Optional version id. When provided, exampleConfig reflects that version's resolved defaults.",
+    ),
+});
+
+const previewInputSchema = z.object({
+  templateId: z.string().describe("The template id from assistantUITemplates"),
+  versionId: z
+    .string()
+    .optional()
+    .describe("Version id to use. Uses the template default if omitted."),
+  config: z
+    .record(z.string(), z.unknown())
+    .optional()
+    .describe(
+      "Customization config for the preview. Must contain only the top-level keys: hostUi, assistant, and brandTheme. " +
+        "Use the schemas from assistantUITemplateDetails.configRoots as the source of truth for each root. " +
+        "Do not pass any other root keys.",
+    ),
+});
+
+function withDegradedNote<T extends Record<string, unknown>>(
+  payload: T,
+  degraded: boolean,
+  degradedReason?: string,
+): T & { catalogDegraded?: true; catalogDegradedReason?: string } {
+  if (!degraded) return payload;
+  return {
+    ...payload,
+    catalogDegraded: true,
+    ...(degradedReason ? { catalogDegradedReason: degradedReason } : {}),
+  };
+}
+
+export const xuluxTemplatesListTool = {
+  name: "assistantUITemplates",
+  description:
+    "List the available assistant-ui hosted app templates and fixed demos with their features, customizable surfaces, and versions. " +
+    "Call this first for any assistant-ui app-building request. Use the features and customizable fields to decide which template fits. " +
+    "If customizable is empty, the entry is a fixed demo that should be used as-is rather than configured. " +
+    "Call assistantUITemplateDetails on the chosen template before requesting a preview.",
+  parameters: emptyInputSchema.shape,
+  execute: async (_args: z.infer<typeof emptyInputSchema>) => {
+    logger.info("Listing assistant-ui templates");
+    try {
+      const { catalog, degraded, degradedReason } = await getXuluxCatalog();
+      return formatMCPResponse(
+        withDegradedNote(listTemplates(catalog), degraded, degradedReason),
+      );
+    } catch (error) {
+      logger.error("Failed to list assistant-ui templates", error);
+      return formatMCPResponse({
+        error: "Failed to list assistant-ui templates",
+        message: error instanceof Error ? error.message : String(error),
+      });
+    }
+  },
+};
+
+export const xuluxTemplateDetailsTool = {
+  name: "assistantUITemplateDetails",
+  description:
+    "Get the full authoring surface for a specific assistant-ui hosted template. " +
+    "Returns configRoots schemas (with types, defaults, and enums), rules, built-in tool input/outputShape, renderer contracts, and an exampleConfig. " +
+    "Fixed demos return no configRoots; use those as-is without config. " +
+    "Use this before calling assistantUITemplatePreview to understand exactly what config to write. " +
+    "If assistantUITemplatePreview returns validationWarnings, call this again and cross-reference configRoots to correct the config.",
+  parameters: detailsInputSchema.shape,
+  execute: async (args: z.infer<typeof detailsInputSchema>) => {
+    logger.info(
+      `Getting assistant-ui template details for: ${args.templateId}`,
+    );
+    try {
+      const { catalog, degraded, degradedReason } = await getXuluxCatalog();
+      const details = await getTemplateDetails(catalog, args);
+      return formatMCPResponse(
+        withDegradedNote(
+          details as unknown as Record<string, unknown>,
+          degraded,
+          degradedReason,
+        ),
+      );
+    } catch (error) {
+      logger.error("Failed to get assistant-ui template details", error);
+      return formatMCPResponse({
+        error: "Failed to get assistant-ui template details",
+        message: error instanceof Error ? error.message : String(error),
+      });
+    }
+  },
+};
+
+export const xuluxTemplatePreviewTool = {
+  name: "assistantUITemplatePreview",
+  description:
+    "Return preview and download URLs for a selected assistant-ui hosted template. " +
+    "The previewUrl is a hosted app URL; show it to the user first, or open it with an available browser/in-app-browser tool if your client provides one. " +
+    "If you pass config, a preview session is created on the hosted template sandbox and the returned URLs reflect that configuration. " +
+    "Do not pass config for fixed demos that have no configRoots in assistantUITemplateDetails. " +
+    "This tool only returns URLs.",
+  parameters: previewInputSchema.shape,
+  execute: async (args: z.infer<typeof previewInputSchema>) => {
+    logger.info(
+      `Creating assistant-ui template preview for: ${args.templateId}`,
+    );
+    try {
+      const { catalog, degraded, degradedReason } = await getXuluxCatalog();
+      const result = await createTemplatePreview(catalog, args);
+      return formatMCPResponse(
+        withDegradedNote(
+          result as unknown as Record<string, unknown>,
+          degraded,
+          degradedReason,
+        ),
+      );
+    } catch (error) {
+      logger.error("Failed to create assistant-ui template preview", error);
+      return formatMCPResponse({
+        error: "Failed to create assistant-ui template preview",
+        message: error instanceof Error ? error.message : String(error),
+      });
+    }
+  },
+};

package/src/utils/cache.ts

@@ -0,0 +1,20 @@
+export function cacheListing(
+  scan: () => Promise<string[]>,
+): () => Promise<string[]> {
+  let cache: Promise<string[]> | null = null;
+  return () => {
+    if (!cache) {
+      cache = scan().then(
+        (result) => {
+          if (result.length === 0) cache = null;
+          return result;
+        },
+        (error) => {
+          cache = null;
+          throw error;
+        },
+      );
+    }
+    return cache;
+  };
+}

package/src/utils/mcp-format.ts

@@ -1,12 +1,14 @@
 export function formatMCPResponse(data: any): {
   content: Array<{ type: "text"; text: string }>;
+  structuredContent?: Record<string, unknown>;
 } {
+  const text = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+  const isStructured =
+    typeof data === "object" && data !== null && !Array.isArray(data);
   return {
-    content: [
-      {
-        type: "text",
-        text: typeof data === "string" ? data : JSON.stringify(data, null, 2),
-      },
-    ],
+    content: [{ type: "text", text }],
+    ...(isStructured && {
+      structuredContent: data as Record<string, unknown>,
+    }),
   };
 }

package/src/utils/paths.ts

@@ -1,6 +1,7 @@
 import { readdir, stat } from "node:fs/promises";
 import { join, extname } from "node:path";
 import { DOCS_PATH, MDX_EXTENSION, MD_EXTENSION } from "../constants.js";
+import { cacheListing } from "./cache.js";
 import { logger } from "./logger.js";
 
 const SIMILARITY_THRESHOLDS = {
@@ -66,7 +67,9 @@ export async function getAvailablePaths(): Promise<string[]> {
   return paths.sort();
 }
 
-export async function getAvailableDocFiles(): Promise<string[]> {
+export const getAvailableDocFiles = cacheListing(scanDocFiles);
+
+async function scanDocFiles(): Promise<string[]> {
   const files: string[] = [];
 
   async function scanDirectory(dir: string, prefix = ""): Promise<void> {

package/src/utils/tests/cache.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect } from "vitest";
+import { cacheListing } from "../cache.js";
+
+describe("cacheListing", () => {
+  it("scans once and reuses the result", async () => {
+    let calls = 0;
+    const listing = cacheListing(async () => {
+      calls++;
+      return ["a", "b"];
+    });
+    const first = await listing();
+    const second = await listing();
+    expect(second).toBe(first);
+    expect(calls).toBe(1);
+  });
+
+  it("shares one in-flight scan across concurrent callers", async () => {
+    let calls = 0;
+    const listing = cacheListing(async () => {
+      calls++;
+      return ["a"];
+    });
+    const [first, second] = await Promise.all([listing(), listing()]);
+    expect(second).toBe(first);
+    expect(calls).toBe(1);
+  });
+
+  it("re-scans after a failed scan", async () => {
+    let calls = 0;
+    const listing = cacheListing(async () => {
+      calls++;
+      if (calls === 1) throw new Error("boom");
+      return ["a"];
+    });
+    await expect(listing()).rejects.toThrow("boom");
+    expect(await listing()).toEqual(["a"]);
+    expect(calls).toBe(2);
+  });
+
+  it("does not cache an empty listing", async () => {
+    let calls = 0;
+    const listing = cacheListing(async () => {
+      calls++;
+      return calls === 1 ? [] : ["a"];
+    });
+    expect(await listing()).toEqual([]);
+    expect(await listing()).toEqual(["a"]);
+    expect(await listing()).toEqual(["a"]);
+    expect(calls).toBe(2);
+  });
+});

package/src/utils/tests/mcp-format.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from "vitest";
+import { formatMCPResponse } from "../mcp-format.js";
+
+describe("formatMCPResponse", () => {
+  it("attaches structuredContent for object data, mirroring the text block", () => {
+    const data = { found: true, path: "getting-started", type: "file" };
+    const res = formatMCPResponse(data);
+    expect(res.content[0]!.text).toBe(JSON.stringify(data, null, 2));
+    expect(res.structuredContent).toEqual(data);
+  });
+
+  it("omits structuredContent for string data", () => {
+    const res = formatMCPResponse("plain text");
+    expect(res.content[0]!.text).toBe("plain text");
+    expect(res.structuredContent).toBeUndefined();
+  });
+
+  it("omits structuredContent for array data", () => {
+    const res = formatMCPResponse([1, 2, 3] as any);
+    expect(res.structuredContent).toBeUndefined();
+  });
+});

package/src/utils/tests/security.test.ts

@@ -85,7 +85,7 @@ describe("sanitizePath", () => {
       },
       { input: "guides/tools", expected: "guides/tools" },
       { input: "docs/index", expected: "docs/index" },
-      { input: "examples/with-ai-sdk-v6", expected: "examples/with-ai-sdk-v6" },
+      { input: "examples/with-ai-sdk-v7", expected: "examples/with-ai-sdk-v7" },
       { input: "./current-dir-file", expected: "current-dir-file" },
       {
         input: "deeply/nested/path/to/file",