@wix/ditto-codegen-public 1.0.357 → 1.0.358

package/dist/opencode-tools/wix-generate.ts

@@ -0,0 +1,130 @@
+import { tool } from "@opencode-ai/plugin";
+import { readFile } from "fs/promises";
+import { join, isAbsolute, relative } from "path";
+
+// `wix generate --params <json>` prints one JSON line to stdout (`--params` implies
+// `--json`; see wix-cli commands/generate.tsx). We only depend on `newFiles`; any
+// other shape is treated as a failure and surfaced to the agent verbatim.
+interface GenerateResult {
+  success: boolean;
+  extensionType?: string;
+  newFiles?: string[];
+  error?: string;
+}
+
+function asResult(raw: string): GenerateResult | null {
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && "success" in parsed
+      ? (parsed as GenerateResult)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+// Extract the JSON result object from stdout. The CLI prints the result as a
+// single JSON line, but may surround it with unrelated lines (e.g. an npm
+// "Update available" notice box), so we can't assume the whole output is JSON:
+// try the whole output first, then fall back to scanning individual lines.
+function parseGenerateOutput(stdout: string): GenerateResult | null {
+  const whole = asResult(stdout.trim());
+  if (whole) return whole;
+
+  for (const line of stdout.split("\n")) {
+    const result = asResult(line.trim());
+    if (result) return result;
+  }
+
+  return null;
+}
+
+export default tool({
+  description:
+    "Scaffold one or more Wix extensions non-interactively via `wix generate --params`. " +
+    "The Wix CLI writes the boilerplate (extension file, config, and registration) " +
+    "deterministically, and this tool returns the full contents of every file it created " +
+    "so you can edit them directly WITHOUT reading them back. Strongly prefer this over " +
+    "hand-writing extension boilerplate.",
+  args: {
+    extensions: tool.schema
+      .array(
+        tool.schema.object({
+          params: tool.schema
+            .object({
+              extensionType: tool.schema
+                .string()
+                .describe("The extension type to generate."),
+            })
+            .passthrough()
+            .describe(
+              "The `wix generate --params` config object: `extensionType` plus the " +
+                "type-specific fields (e.g. a DATA_COLLECTION needs `collectionName`, an " +
+                "EVENT needs an event identifier). Discover the exact fields for each type " +
+                "via the wix-app skill or `wix schema generate`.",
+            ),
+        }),
+      )
+      .describe(
+        "The extensions to scaffold. Each entry runs one `wix generate --params` call; " +
+          "pass several to scaffold them in a single tool call.",
+      ),
+  },
+  async execute(args, context) {
+    const cwd = context.directory;
+    const blocks: string[] = [];
+
+    for (const { params } of args.extensions) {
+      const type =
+        typeof params.extensionType === "string" ? params.extensionType : "?";
+
+      const res = await Bun.$`npx wix generate --params ${JSON.stringify(params)}`
+        .cwd(cwd)
+        .nothrow()
+        .quiet();
+
+      const stdout = res.stdout.toString();
+      const result = parseGenerateOutput(stdout);
+
+      // No recognizable `--json` result line: the CLI's output contract likely
+      // changed. A format change breaks every extension equally, so don't emit
+      // per-extension FAILED noise — abort the batch with one message telling the
+      // agent to fall back to running `wix generate` itself via bash.
+      if (!result) {
+        return [
+          "=== wix-generate could not read `wix generate` output ===",
+          "`wix generate --params` did not return its expected JSON result, so this " +
+            "tool can't extract the created files (the CLI output format may have " +
+            "changed). Fall back to the bash tool: run " +
+            "`npx wix generate --params '<params-json>'` for each extension yourself, " +
+            "then read the files it creates.",
+          "",
+          `Raw output (exit ${res.exitCode}):`,
+          stdout.trim() || res.stderr.toString().trim() || "(no output)",
+        ].join("\n");
+      }
+
+      const newFiles = result.success ? result.newFiles : undefined;
+
+      if (!newFiles?.length) {
+        const detail =
+          result.error ||
+          res.stderr.toString().trim() ||
+          stdout.trim() ||
+          "(no output)";
+        blocks.push(`=== FAILED: ${type} (exit ${res.exitCode}) ===\n${detail}`);
+        continue;
+      }
+
+      const files = await Promise.all(
+        newFiles.map(async (file) => {
+          const abs = isAbsolute(file) ? file : join(cwd, file);
+          return `--- ${relative(cwd, abs)} ---\n${await readFile(abs, "utf-8")}`;
+        }),
+      );
+      blocks.push(`=== ${result.extensionType ?? type} ===\n${files.join("\n\n")}`);
+    }
+
+    return blocks.join("\n\n");
+  },
+});

package/dist/out.js

@@ -12170,6 +12170,7 @@ TOOL USAGE:
   - "Building project"
 - \`validate\` for all validation (tsc + build).
 - \`uuid\` to generate UUIDs (supports count param for multiple). Do NOT use bash.
+- \`wix-generate\` to scaffold extensions non-interactively (wraps \`wix generate --params\`). Prefer it over hand-writing extension boilerplate. It RETURNS the full contents of every file the CLI created, so trust that output and do NOT \`read\`/\`batch-read\` those files afterward. If it returns a \`FAILED\` block, fix the params per the error and retry. Pass an array to scaffold several extensions in one call.
 - \`required-permissions\` to declare the Wix app permissions the generated code needs. Call it ONCE at the end, and ONLY if permissions are actually needed \u2014 don't call it otherwise (see PERMISSIONS).
 - File operations \u2014 pick the BATCH tool whenever you have 2+ files; the single-file variants are 5\u201310\xD7 slower:
   - \`batch-write\` to create N new files in one call. NEVER call \`write\` more than once per turn \u2014 use batch-write instead. \`write\` is reserved for single-file creation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/ditto-codegen-public",
-  "version": "1.0.357",
+  "version": "1.0.358",
   "description": "AI-powered Wix CLI app generator - standalone executable",
   "scripts": {
     "build": "node build.mjs",
@@ -29,5 +29,5 @@
     "esbuild": "^0.27.2",
     "vitest": "^4.0.16"
   },
-  "falconPackageHash": "236fead8ed789d2e79367a542151458b9890fc135b057e67784bb6f9"
+  "falconPackageHash": "d71ce4d5b338ba060f5d9cf26324f43ddd3dae5b5120be5e30903e01"
 }