@wix/ditto-codegen-public 1.0.483 → 1.0.484

package/dist/opencode-tools/validate.ts

@@ -1,5 +1,6 @@
 import { tool } from "@opencode-ai/plugin";
-import { readdir } from "node:fs/promises";
+import { readdir, readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
 import { join } from "node:path";
 
 const EDITOR_COMPONENTS_DIR = "src/extensions/site/components";
@@ -15,12 +16,173 @@ async function containsTypeScriptFile(directory: string): Promise<boolean> {
 
   for (const entry of entries) {
     const path = join(directory, entry.name);
-    if (entry.isDirectory() && (await containsTypeScriptFile(path))) return true;
+    if (entry.isDirectory() && (await containsTypeScriptFile(path)))
+      return true;
     if (entry.isFile() && /\.tsx?$/.test(entry.name)) return true;
   }
   return false;
 }
 
+const SAFE_SPECIFIER = /^[\w@./-]{1,100}$/;
+
+const MISSING_SPECIFIER_FIX: Record<string, string> = {
+  contextProvider:
+    "add `moduleSpecifier: '<prefix><provider-kebab-case-name>'` to resources.contextSpecifier",
+  functionLibrary:
+    "add `moduleSpecifier: '<prefix><library-name>'` to resources",
+};
+
+type TypeScript = typeof import("typescript");
+
+// The project's own TypeScript (the one its tsc step uses), else ours.
+function loadTypeScript(cwd: string): TypeScript | undefined {
+  for (const base of [cwd, process.cwd()]) {
+    try {
+      return createRequire(join(base, "package.json"))(
+        "typescript",
+      ) as TypeScript;
+    } catch {
+      continue;
+    }
+  }
+  return undefined;
+}
+
+// Reads moduleSpecifier only from the object passed to contextProvider() or
+// functionLibrary(), so comments, strings and other calls never count. A value
+// is undefined unless it is a plain single-line quoted string.
+function readModuleSpecifiers(
+  ts: TypeScript,
+  file: string,
+  source: string,
+): { kind?: string; values: (string | undefined)[] } {
+  const found: { kind?: string; values: (string | undefined)[] } = {
+    values: [],
+  };
+  const visit = (node: import("typescript").Node, inCall: boolean): void => {
+    if (ts.isCallExpression(node)) {
+      const callee = node.expression;
+      const name = ts.isPropertyAccessExpression(callee)
+        ? callee.name.text
+        : ts.isIdentifier(callee)
+          ? callee.text
+          : undefined;
+      if (name === "contextProvider" || name === "functionLibrary") {
+        found.kind ??= name;
+        node.arguments.forEach((argument) => visit(argument, true));
+        return;
+      }
+    }
+    if (
+      inCall &&
+      (ts.isPropertyAssignment(node) || ts.isShorthandPropertyAssignment(node))
+    ) {
+      const key =
+        ts.isIdentifier(node.name) || ts.isStringLiteral(node.name)
+          ? node.name.text
+          : undefined;
+      if (key === "moduleSpecifier") {
+        const value =
+          ts.isPropertyAssignment(node) &&
+          ts.isStringLiteral(node.initializer) &&
+          !/['"`\r\n]/.test(node.initializer.text)
+            ? node.initializer.text
+            : undefined;
+        found.values.push(value);
+        return;
+      }
+    }
+    ts.forEachChild(node, (child) => visit(child, inCall));
+  };
+  visit(ts.createSourceFile(file, source, ts.ScriptTarget.Latest), false);
+  return found;
+}
+
+async function checkModuleSpecifiers(cwd: string): Promise<string | undefined> {
+  const prefix = process.env.MODULE_SPECIFIER_PREFIX;
+  if (!prefix) return undefined;
+
+  const gitEnv = { ...process.env, LC_ALL: "C" };
+  const listings = await Promise.all([
+    Bun.$`git ls-files --others --exclude-standard -- src`
+      .cwd(cwd)
+      .env(gitEnv)
+      .nothrow()
+      .quiet(),
+    Bun.$`git diff --cached --name-only --diff-filter=A --relative -- src`
+      .cwd(cwd)
+      .env(gitEnv)
+      .nothrow()
+      .quiet(),
+  ]);
+  for (const listing of listings) {
+    const stderr = listing.stderr.toString();
+    if (listing.exitCode === 0) continue;
+    if (
+      listing.exitCode === 128 &&
+      /^fatal: not a git repository\b/m.test(stderr)
+    )
+      return undefined;
+    return `FAILED at moduleSpecifier prefix check: git exited ${listing.exitCode}:\n${stderr}`;
+  }
+  const newExtensionFiles = [
+    ...new Set(
+      listings
+        .flatMap((listing) => listing.stdout.toString().split("\n"))
+        .map((file) => file.trim())
+        .filter((file) => file.endsWith(".extension.ts")),
+    ),
+  ];
+
+  const violations: string[] = [];
+  const ts = newExtensionFiles.length > 0 ? loadTypeScript(cwd) : undefined;
+  if (newExtensionFiles.length > 0 && !ts) {
+    violations.push(
+      "- cannot load the project's typescript package to read moduleSpecifier; run npm install",
+    );
+  }
+  for (const file of newExtensionFiles) {
+    if (!ts) break;
+    const source = await readFile(join(cwd, file), "utf8").catch(() => "");
+    const { kind, values } = readModuleSpecifiers(ts, file, source);
+    if (!kind) continue;
+    if (values.length === 0) {
+      violations.push(
+        `- ${file}: no moduleSpecifier; ${MISSING_SPECIFIER_FIX[kind].replace("<prefix>", prefix)}`,
+      );
+      continue;
+    }
+    for (const specifier of values) {
+      if (specifier === undefined) {
+        violations.push(
+          `- ${file}: moduleSpecifier is not a plain string literal; write it as '${prefix}<name>'`,
+        );
+      } else if (specifier.length > 100) {
+        violations.push(
+          `- ${file}: moduleSpecifier is over 100 characters; shorten it to '${prefix}<name>'`,
+        );
+      } else if (!specifier.startsWith(prefix)) {
+        violations.push(
+          SAFE_SPECIFIER.test(specifier) &&
+            prefix.length + specifier.length <= 100
+            ? `- ${file}: '${specifier}' -> '${prefix}${specifier}'`
+            : `- ${file}: moduleSpecifier must be '${prefix}<name>' (letters, digits, @ . _ / - only, at most 100 characters)`,
+        );
+      }
+    }
+  }
+  if (violations.length === 0) return undefined;
+
+  return [
+    "FAILED at moduleSpecifier prefix check:",
+    ...violations,
+    `Every new context provider and function library must declare a moduleSpecifier that starts with '${prefix}'. ` +
+      "Module specifiers are unique across all of Wix, so an unprefixed one can belong to " +
+      'another app and fail the checkpoint with "Error during component specifier upsert". ' +
+      "Only new extensions are checked: never change the moduleSpecifier of an existing one.",
+  ].join("\n");
+}
+
 export default tool({
   description:
     "Run project validation: TypeScript check by default, optionally a full build " +
@@ -74,6 +236,9 @@ export default tool({
     }
     steps.push("tsc --noEmit -p .: OK");
 
+    const specifierError = await checkModuleSpecifiers(cwd);
+    if (specifierError) return [...steps, specifierError].join("\n");
+
     if (!args.runBuild) {
       steps.push("wix build: skipped (pass runBuild: true to verify build)");
       return steps.join("\n");
@@ -94,9 +259,7 @@ export default tool({
       join(cwd, EDITOR_COMPONENTS_DIR),
     );
     if (!hasEditorComponents) {
-      steps.push(
-        "wix generate manifest: skipped (no editor components)",
-      );
+      steps.push("wix generate manifest: skipped (no editor components)");
       return steps.join("\n");
     }