jui-tools-mcp-server 2.13.0 → 2.14.0

package/dist/tools/spec/get_data_source.js

@@ -1,7 +1,8 @@
 export function register(server, loader) {
-    server.tool("get_data_source", "Report where the MCP server loaded EVERY canonical data file from — attribute_definitions.json (raw schema), component_metadata.json (presentation metadata), screen_identity.json and binding_semantics.json. Shows layer (env / cwd / home / bundled), the absolute path actually read, file mtime and freshness per file, plus when this server process loaded them. Use it when the CLI and the MCP seem to disagree about the canon: since 2.12.0 every tool call re-reads a file whose CONTENT changed (sha256, not mtime), so a restart is not needed after a jsonui-cli distribution; `lastReload` says when that last happened and whether it succeeded, and `staleInMemory` is non-empty only when a reload FAILED (a file did not parse) and the server is still serving the previous content.", {}, async () => {
+    server.tool("get_data_source", "Report where the MCP server loaded EVERY canonical data file from — attribute_definitions.json (raw schema), component_metadata.json (presentation metadata), screen_identity.json, binding_semantics.json and the rest, down to type_synonyms.json (the type spellings the build accepts). Shows layer (env / cwd / home / bundled), the absolute path actually read, file mtime and freshness per file, plus when this server process loaded them. Use it when the CLI and the MCP seem to disagree about the canon: since 2.12.0 every tool call re-reads a file whose CONTENT changed (sha256, not mtime), so a restart is not needed after a jsonui-cli distribution; `lastReload` says when that last happened and whether it succeeded, and `staleInMemory` is non-empty only when a reload FAILED (a file did not parse) and the server is still serving the previous content.", {}, async () => {
         const info = loader.getDataSource();
-        // 🚨 THE SAME SEVEN THE STALENESS CHECK WATCHES. This list held five
+        // 🚨 THE SAME FILES THE STALENESS CHECK WATCHES (eight since
+        // type_synonyms.json). This list held five
         // while `getChangedSinceLoad` tracked seven, so `staleInMemory` could
         // name a path that appeared in no per-file entry — and a reader who
         // "checked every file reported" had two outside their view. Reported by
@@ -15,6 +16,7 @@ export function register(server, loader) {
             info.attributeSemantics,
             info.platformSemantics,
             info.coverage,
+            info.typeSynonyms,
         ].filter((f) => f != null);
         const stale = files.some((f) => f.freshness === "stale");
         // The data is read once at construction and cached in memory, so a
@@ -35,6 +37,7 @@ export function register(server, loader) {
                         attributeSemantics: info.attributeSemantics,
                         platformSemantics: info.platformSemantics,
                         coverage: info.coverage,
+                        typeSynonyms: info.typeSynonyms,
                         componentCount: info.componentCount,
                         commonAttributeCount: info.commonAttributeCount,
                         loadedAt,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jui-tools-mcp-server",
-  "version": "2.13.0",
+  "version": "2.14.0",
   "description": "MCP server for JsonUI project management - wraps jui and jsonui-doc CLIs plus component spec lookup",
   "main": "dist/index.js",
   "scripts": {

package/scripts/fetch-definitions.js

@@ -44,7 +44,7 @@ const DATA_DIR = join(PROJECT_ROOT, "data");
 //   3. `npm run fetch-definitions` and commit the data/ diff together with
 //      this pin in one commit
 // JSONUI_CLI_RAW_BASE still overrides the whole base URL for manual testing.
-const JSONUI_CLI_TAG = "v1.8.110";
+const JSONUI_CLI_TAG = "v1.9.0";
 const BASE_URL =
   process.env.JSONUI_CLI_RAW_BASE ||
   `https://raw.githubusercontent.com/Tai-Kimura/jsonui-cli/${JSONUI_CLI_TAG}`;

package/scripts/fetch-manifest.js

@@ -59,6 +59,12 @@ export const FILES = [
   // Conformance coverage ledger (declared-but-unimplemented gaps). The loader
   // reads data/coverage.json as its fallback, so it must refresh with the rest
   // — binding_semantics.json already fell into this exact stale-snapshot trap.
+  // Type-spelling synonyms (jsonui-cli 1.9.0): lookup_component and
+  // search_components resolve ProgressBar, HStack, Text … through it.
+  {
+    remote: "shared/core/type_synonyms.json",
+    local: "type_synonyms.json",
+  },
   {
     remote: "conformance/coverage.json",
     local: "coverage.json",

package/src/cli_runner.ts

@@ -14,7 +14,7 @@ export async function runCli(
   const timeout = options.timeout ?? 60_000;
 
   return new Promise((resolve) => {
-    execFile(
+    const child = execFile(
       command,
       args,
       {
@@ -39,6 +39,12 @@ export async function runCli(
         });
       }
     );
+    // Nothing is ever written to the child's stdin: end it now, so a CLI that
+    // reads stdin — an overwrite prompt — sees end-of-file instead of waiting
+    // for a line that never comes. Through 2.13.1 the pipe stayed open, and such
+    // a child waited until the timeout above killed it (`jui g converter` on
+    // an existing component, measured 2026-09-26).
+    child.stdin?.end();
   });
 }
 

package/src/spec_loader.ts

@@ -90,6 +90,17 @@ export interface ReloadRecord {
   error?: string;
 }
 
+/// A spelling the build accepts for a type it is not, as type_synonyms.json
+/// says: its canonical section, the type it is drawn as when that differs,
+/// and the attributes the spelling itself means.
+export interface TypeSynonym {
+  spelling: string;
+  canonical: string;
+  renderAs?: string;
+  implies?: Record<string, unknown>;
+  source: string;
+}
+
 export interface DataSourceInfo {
   attributeDefinitions: FileInfo;
   componentMetadata: FileInfo;
@@ -111,6 +122,10 @@ export interface DataSourceInfo {
   /// attribute, platform) pairs with their recorded reasons. Optional: absent
   /// on older jsonui-cli checkouts.
   coverage: FileInfo | null;
+  /// shared/core/type_synonyms.json — type spellings the build accepts for a
+  /// section they are not (ProgressBar, HStack, Text …). Optional: absent on
+  /// jsonui-cli before 1.9.0.
+  typeSynonyms: FileInfo | null;
   componentCount: number;
   commonAttributeCount: number;
 }
@@ -157,6 +172,10 @@ export class SpecLoader {
   private screenIdentity: Record<string, any> | null = null;
   private commonAttributes: any = null;
   private aliasMap: Map<string, string> = new Map();
+  /// Lower-cased spelling -> its entry in type_synonyms.json, for the
+  /// spellings that resolve through it (not a section, `_alias_of` or
+  /// metadata alias of their own).
+  private typeSynonyms: Map<string, TypeSynonym> = new Map();
   private metadata: Record<string, ComponentMetadata> = {};
   private dataSource!: DataSourceInfo;
   /** When this process read the files. Data is cached in memory from then
@@ -223,6 +242,13 @@ export class SpecLoader {
   getComponentWithCommon(name: string): any {
     const comp = this.getComponent(name);
     if (!comp) return null;
+    // Say which spelling was asked for and why it resolved: the build
+    // accepts `ProgressBar` as a Progress, and an HStack is a View that
+    // also means `orientation: horizontal`.
+    const synonym = this.typeSynonyms.get(name.toLowerCase());
+    if (synonym) {
+      return { ...comp, typeSynonym: synonym, commonAttributes: this.commonAttributes };
+    }
     return { ...comp, commonAttributes: this.commonAttributes };
   }
 
@@ -312,6 +338,15 @@ export class SpecLoader {
         }
       }
 
+      // A spelling the build accepts for this type (type_synonyms.json).
+      for (const synonym of this.typeSynonyms.values()) {
+        if (this.getComponent(synonym.spelling) !== comp) continue;
+        if (synonym.spelling.toLowerCase().includes(q)) {
+          score += 8;
+          matches.push(`type synonym: ${synonym.spelling}`);
+        }
+      }
+
       if (score > 0) results.push({ component: comp.name, score, matches });
     }
 
@@ -422,6 +457,7 @@ export class SpecLoader {
       this.dataSource.attributeSemantics,
       this.dataSource.platformSemantics,
       this.dataSource.coverage,
+      this.dataSource.typeSynonyms,
     ].filter((f): f is FileInfo => f != null);
 
     const changed: string[] = [];
@@ -635,6 +671,8 @@ export class SpecLoader {
       componentCount++;
     }
 
+    const typeSynonymsResolution = this.loadTypeSynonyms();
+
     this.dataSource = {
       attributeDefinitions: attrResolution,
       componentMetadata: metaResolution,
@@ -643,6 +681,7 @@ export class SpecLoader {
       attributeSemantics: attributeSemanticsResolution,
       platformSemantics: platformSemanticsResolution,
       coverage: coverageResolution,
+      typeSynonyms: typeSynonymsResolution,
       componentCount,
       commonAttributeCount: Object.keys(this.commonAttributesRaw).filter(
         (k) => !k.startsWith("_")
@@ -650,6 +689,52 @@ export class SpecLoader {
     };
   }
 
+  /**
+   * Type spellings the build accepts for a section they are not
+   * (shared/core/type_synonyms.json, jsonui-cli 1.9.0 — the one table the
+   * tools and the dynamic runtimes read). Until then lookup_component knew
+   * only `_alias_of` sections and metadata aliases, and answered "not found"
+   * for `ProgressBar`, which the build draws as a Progress.
+   *
+   * A section, an `_alias_of` section or a metadata alias of the same
+   * spelling wins: the exact match is found first, as in the tools. An entry
+   * whose canonical is not a section here is skipped.
+   *
+   * Absent (older jsonui-cli): no synonyms. Present but not JSON: the load
+   * throws, so an automatic reload keeps the last content that parsed rather
+   * than swapping in a loader that silently lost every synonym.
+   */
+  private loadTypeSynonyms(): FileInfo | null {
+    this.typeSynonyms = new Map();
+    let resolution: FileInfo;
+    try {
+      resolution = this.resolveFile("shared/core/type_synonyms.json", "data/type_synonyms.json");
+    } catch {
+      return null;
+    }
+    const doc = JSON.parse(readFileSync(resolution.path, "utf-8")) as {
+      synonyms?: Record<string, Record<string, unknown>>;
+    };
+    for (const [spelling, entry] of Object.entries(doc.synonyms ?? {})) {
+      if (typeof entry !== "object" || entry === null) continue;
+      const { canonical, render_as: renderAs, ...implies } = entry;
+      if (typeof canonical !== "string" || canonical.length === 0) continue;
+      const key = spelling.toLowerCase();
+      if (this.components.has(key) || this.aliasMap.has(key)) continue;
+      const target = this.aliasMap.get(canonical.toLowerCase()) ?? canonical.toLowerCase();
+      if (!this.components.has(target)) continue;
+      this.aliasMap.set(key, target);
+      this.typeSynonyms.set(key, {
+        spelling,
+        canonical,
+        ...(typeof renderAs === "string" ? { renderAs } : {}),
+        ...(Object.keys(implies).length > 0 ? { implies } : {}),
+        source: "shared/core/type_synonyms.json",
+      });
+    }
+    return resolution;
+  }
+
   private normalizeMetadata(raw: Record<string, any>): ComponentMetadata {
     return {
       description: raw.description ?? "",

package/src/tools/jui/jui_generate_converter.ts

@@ -12,7 +12,12 @@ export function register(server: McpServer, config: ServerConfig) {
       from_spec: z.string().optional().describe("Generate from component spec file path"),
       all: z.boolean().optional().describe("Generate from all component specs"),
       attributes: z.string().optional().describe("Attributes in key:type format (e.g., 'prop1:String,prop2:Int')"),
-      container: z.boolean().optional().describe("Mark as container component"),
+      container: z.boolean().optional().describe(
+        "true: a container (it draws its children). false: a leaf (it takes no " +
+        "children, and a layout that gives it some is refused by name) — needs " +
+        "jsonui-cli 1.9.0 or later (earlier `jui` rejects --no-container). " +
+        "Absent: the default form."
+      ),
       skip_existing: z.boolean().optional().describe(
         "Leave existing converter and scaffold files untouched, without the " +
         "overwrite prompt — for idempotent scaffold runs. Wins over `force` " +
@@ -34,7 +39,10 @@ export function register(server: McpServer, config: ServerConfig) {
         if (params.from_spec) { args.push("--from", params.from_spec); }
         if (params.all) { args.push("--all"); }
         if (params.attributes) { args.push("--attributes", params.attributes); }
-        if (params.container) { args.push("--container"); }
+        // `false` asks for a leaf. It used to pass nothing, so the command ran
+        // in the default form and the request was dropped without a word.
+        if (params.container === true) { args.push("--container"); }
+        if (params.container === false) { args.push("--no-container"); }
         if (params.skip_existing) { args.push("--skip-existing"); }
         if (params.force) { args.push("--force"); }
 

package/src/tools/jui/jui_generate_project.ts

@@ -6,10 +6,21 @@ import { runCli, formatResult } from "../../cli_runner.js";
 export function register(server: McpServer, config: ServerConfig) {
   server.tool(
     "jui_generate_project",
-    "Generate Layout JSON and ViewModel files from screen specs (all or single spec)",
+    "Generate Layout JSON and ViewModel files from screen specs (all or single spec). " +
+      "A Layout JSON it generates — a screen's, or a Collection cell / header / footer's — is " +
+      "written when it is not there, left as it is when it already holds exactly what the spec " +
+      "generates, and otherwise KEPT (the Layout JSON is hand-edited after generation) and named " +
+      "in the output with \"Kept existing … layout: <file> … --force replaces it\". From " +
+      "jsonui-cli 1.9.0; an earlier jui rewrote an existing layout on every run.",
     {
       spec_file: z.string().optional().describe("Single spec file to process (e.g., 'login.spec.json')"),
-      force: z.boolean().optional().describe("Force overwrite declaration files"),
+      force: z.boolean().optional().describe(
+        "Replace the ViewModel declaration files, and each Layout JSON that already exists and " +
+          "differs from what the spec generates (kept and named without it). A layout whose data " +
+          "section holds entries the spec does not declare is not replaced even with force — the " +
+          "output names them. Called from here the command has no terminal, so it never asks: " +
+          "without force an existing layout is kept."
+      ),
       skip_layout: z.boolean().optional().describe("Skip Layout JSON generation"),
       dry_run: z.boolean().optional().describe("Show what would be generated without writing"),
       platform: z.enum(["ios", "android", "web"]).optional().describe("Generate for single platform only"),

package/src/tools/spec/get_data_source.ts

@@ -4,11 +4,12 @@ import { SpecLoader } from "../../spec_loader.js";
 export function register(server: McpServer, loader: SpecLoader) {
   server.tool(
     "get_data_source",
-    "Report where the MCP server loaded EVERY canonical data file from — attribute_definitions.json (raw schema), component_metadata.json (presentation metadata), screen_identity.json and binding_semantics.json. Shows layer (env / cwd / home / bundled), the absolute path actually read, file mtime and freshness per file, plus when this server process loaded them. Use it when the CLI and the MCP seem to disagree about the canon: since 2.12.0 every tool call re-reads a file whose CONTENT changed (sha256, not mtime), so a restart is not needed after a jsonui-cli distribution; `lastReload` says when that last happened and whether it succeeded, and `staleInMemory` is non-empty only when a reload FAILED (a file did not parse) and the server is still serving the previous content.",
+    "Report where the MCP server loaded EVERY canonical data file from — attribute_definitions.json (raw schema), component_metadata.json (presentation metadata), screen_identity.json, binding_semantics.json and the rest, down to type_synonyms.json (the type spellings the build accepts). Shows layer (env / cwd / home / bundled), the absolute path actually read, file mtime and freshness per file, plus when this server process loaded them. Use it when the CLI and the MCP seem to disagree about the canon: since 2.12.0 every tool call re-reads a file whose CONTENT changed (sha256, not mtime), so a restart is not needed after a jsonui-cli distribution; `lastReload` says when that last happened and whether it succeeded, and `staleInMemory` is non-empty only when a reload FAILED (a file did not parse) and the server is still serving the previous content.",
     {},
     async () => {
       const info = loader.getDataSource();
-      // 🚨 THE SAME SEVEN THE STALENESS CHECK WATCHES. This list held five
+      // 🚨 THE SAME FILES THE STALENESS CHECK WATCHES (eight since
+      // type_synonyms.json). This list held five
       // while `getChangedSinceLoad` tracked seven, so `staleInMemory` could
       // name a path that appeared in no per-file entry — and a reader who
       // "checked every file reported" had two outside their view. Reported by
@@ -22,6 +23,7 @@ export function register(server: McpServer, loader: SpecLoader) {
         info.attributeSemantics,
         info.platformSemantics,
         info.coverage,
+        info.typeSynonyms,
       ].filter((f): f is NonNullable<typeof f> => f != null);
       const stale = files.some((f) => f.freshness === "stale");
       // The data is read once at construction and cached in memory, so a
@@ -43,6 +45,7 @@ export function register(server: McpServer, loader: SpecLoader) {
                 attributeSemantics: info.attributeSemantics,
                 platformSemantics: info.platformSemantics,
                 coverage: info.coverage,
+                typeSynonyms: info.typeSynonyms,
                 componentCount: info.componentCount,
                 commonAttributeCount: info.commonAttributeCount,
                 loadedAt,

package/tests/cli_runner.test.ts

@@ -1,5 +1,6 @@
 /**
- * cli_runner — execFile wrapper. child_process is mocked; no real CLI runs.
+ * cli_runner — execFile wrapper. child_process is mocked; no real CLI runs,
+ * except in "the child's stdin", which calls through to the real execFile.
  */
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
@@ -19,10 +20,14 @@ interface RecordedCall {
 
 let recorded: RecordedCall[];
 let nextResponse: { error?: any; stdout?: string; stderr?: string };
+// The mocked child's stdin: execFile returns a ChildProcess, and runCli ends
+// its stdin.
+let stdinEnd: ReturnType<typeof vi.fn>;
 
 beforeEach(() => {
   recorded = [];
   nextResponse = {};
+  stdinEnd = vi.fn();
   execFileMock.mockReset();
   execFileMock.mockImplementation(
     (command: string, args: string[], options: any, callback: ExecCallback) => {
@@ -32,6 +37,7 @@ beforeEach(() => {
         nextResponse.stdout ?? "",
         nextResponse.stderr ?? ""
       );
+      return { stdin: { end: stdinEnd } };
     }
   );
 });
@@ -101,6 +107,37 @@ describe("runCli", () => {
   });
 });
 
+// execFile gives the child a stdin pipe, and through 2.13.1 nothing wrote to it
+// or closed it: a CLI that read stdin — `sjui / kjui / rjui g converter` at
+// its overwrite prompt, reached through `jui` — waited for a line that never
+// came, until this runner's timeout killed it (60 s by default; measured
+// 2026-09-26 on jsonui-cli, ticket
+// generate-commands-overwrite-edited-files-and-ignore-their-flags). The
+// child's stdin is ended at once: a reader sees end-of-file.
+describe("the child's stdin", () => {
+  it("is ended at once: a child that reads stdin to end-of-file finishes", async () => {
+    const actual = await vi.importActual<typeof import("child_process")>("child_process");
+    execFileMock.mockImplementation((...args: any[]) => (actual.execFile as any)(...args));
+    const reader =
+      "let n = 0; process.stdin.on('data', (c) => { n += c.length; });" +
+      " process.stdin.on('end', () => { console.log('eof after ' + n + ' bytes'); });";
+    const started = Date.now();
+    // runCli's own limit is 5 s: a child left waiting on stdin comes back as
+    // "Command timed out after 5s", and this test's limit (10 s) stops the
+    // suite from waiting longer than that.
+    const result = await runCli(process.execPath, ["-e", reader], { cwd: process.cwd(), timeout: 5_000 });
+    const elapsed = Date.now() - started;
+    expect(result.stderr).not.toMatch(/timed out/);
+    expect(result).toMatchObject({ exitCode: 0, stdout: "eof after 0 bytes\n" });
+    expect(elapsed).toBeLessThan(2_500);
+  }, 10_000);
+
+  it("ends the stdin of the process execFile returns", async () => {
+    await runCli("jui", ["build"], { cwd: "/proj" });
+    expect(stdinEnd).toHaveBeenCalledTimes(1);
+  });
+});
+
 describe("formatResult", () => {
   it("marks exitCode 0 as success and omits empty errors", () => {
     const result: CliResult = { exitCode: 0, stdout: "ok", stderr: "" };

package/tests/snapshot_completeness.test.ts

@@ -47,6 +47,7 @@ function reportedFiles(source: DataSourceInfo) {
     source.attributeSemantics,
     source.platformSemantics,
     source.coverage,
+    source.typeSynonyms,
   ].filter((f): f is NonNullable<typeof f> => f != null);
 }
 

package/tests/staleness_is_content_not_mtime.test.ts

@@ -156,7 +156,7 @@ describe("the per-file report covers what the check tracks", () => {
 
     const reported = new Set(
       ["attributeDefinitions", "componentMetadata", "screenIdentity",
-       "bindingSemantics", "attributeSemantics", "platformSemantics", "coverage"]
+       "bindingSemantics", "attributeSemantics", "platformSemantics", "coverage", "typeSynonyms"]
         .map((k) => out[k]?.path)
         .filter(Boolean)
     );

package/tests/tools_cli.test.ts

@@ -218,6 +218,32 @@ describe("jui_generate_project", () => {
     ]);
     expect(recorded[0].options.timeout).toBe(120_000);
   });
+
+  // jsonui-cli 1.9.0: `jui g project` keeps a Layout JSON that exists and
+  // differs from what the spec generates, names it, and replaces it only with
+  // --force (never one whose data section the spec does not declare). From
+  // MCP it has no terminal, so it never asks. The description says the same,
+  // the flag reaches the CLI only when asked, and the CLI's line naming a kept
+  // file reaches the agent.
+  it("says what happens to a layout that is already there, as the CLI does", async () => {
+    const tool = harness.tools.get("jui_generate_project")!;
+    expect(tool.description).toContain("written when it is not there");
+    expect(tool.description).toContain("left as it is when it already holds exactly what the spec generates");
+    expect(tool.description).toContain("KEPT");
+    expect(tool.description).toContain("--force replaces it");
+    const force = tool.schema.force.description!;
+    expect(force).not.toBe("Force overwrite declaration files");
+    expect(force).toContain("not replaced even with force");
+    expect(force).toContain("never asks");
+
+    nextResponse = {
+      stdout: "Processing: home.spec.json (Home)\n  Kept existing layout: docs/screens/layouts/home.json " +
+        "(it differs from what the spec generates; --force replaces it)\n",
+    };
+    const text = await harness.call("jui_generate_project", { project_dir: projectDir });
+    expect(recorded[0].args).toEqual(["generate", "project"]);
+    expect(text).toContain("Kept existing layout: docs/screens/layouts/home.json");
+  });
 });
 
 describe("jui_generate_screen", () => {
@@ -270,6 +296,23 @@ describe("jui_generate_converter", () => {
     ]);
   });
 
+  // `container: false` is a leaf (`jui g converter --no-container`, jsonui-cli
+  // 1.9.0). It passed nothing before, so a leaf request scaffolded the
+  // default form.
+  it("passes --no-container for container: false, and neither flag when it is absent", async () => {
+    await harness.call("jui_generate_converter", {
+      name: "LeafCard",
+      container: false,
+      project_dir: projectDir,
+    });
+    await harness.call("jui_generate_converter", {
+      name: "PlainCard",
+      project_dir: projectDir,
+    });
+    expect(recorded[0].args).toEqual(["generate", "converter", "LeafCard", "--no-container"]);
+    expect(recorded[1].args).toEqual(["generate", "converter", "PlainCard"]);
+  });
+
   it("maps spec-mode params to flags", async () => {
     await harness.call("jui_generate_converter", {
       from_spec: "docs/components/json/example_card.component.json",

package/tests/tools_test.test.ts

@@ -128,11 +128,11 @@ describe("test_generate_branch_tests", () => {
     nextResponse = { stdout: "ok" };
     await harness.call("test_generate_branch_tests", {
       project_dir: projectDir,
-      screen: "bottle_detail",
+      screen: "item_detail",
       platform: "android",
       package: "com.example.app",
       module: "AppModule",
-      spec: "docs/screens/json/bottle_detail.spec.json",
+      spec: "docs/screens/json/item_detail.spec.json",
       out_dir: "app/src/test/java",
       harness_dir: "app/src/test/java",
       mocks_dir: "tests/mocks",
@@ -140,7 +140,7 @@ describe("test_generate_branch_tests", () => {
     expect(recorded[0].args).toEqual([
       "generate",
       "branch-tests",
-      "bottle_detail",
+      "item_detail",
       "--platform",
       "android",
       "--package",
@@ -148,7 +148,7 @@ describe("test_generate_branch_tests", () => {
       "--module",
       "AppModule",
       "--spec",
-      "docs/screens/json/bottle_detail.spec.json",
+      "docs/screens/json/item_detail.spec.json",
       "--out-dir",
       "app/src/test/java",
       "--harness-dir",