@wix/ditto-codegen-public 1.0.482 → 1.0.484

package/dist/opencode-tools/batch-read.ts

@@ -2,27 +2,75 @@ import { tool } from "@opencode-ai/plugin";
 import { readFile } from "fs/promises";
 import { join, isAbsolute } from "path";
 
+// opencode cuts any tool output over 2,000 lines or 50 KB and saves the rest to
+// a file the agent rarely reads, so every file after the cut is silently lost.
+// Stay well under both limits and name the files that didn't fit instead.
+export const OUTPUT_LIMIT = { bytes: 40 * 1024, lines: 1500 };
+
+const SECTION_SEPARATOR = "\n\n";
+
+async function readSection(
+  filePath: string,
+  directory: string,
+): Promise<string> {
+  const fullPath = isAbsolute(filePath) ? filePath : join(directory, filePath);
+  try {
+    const content = await readFile(fullPath, "utf-8");
+    return `--- ${filePath} ---\n${content}`;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return `--- ${filePath} ---\nERROR: ${msg}`;
+  }
+}
+
+function notReadSection(paths: string[]): string {
+  return (
+    `--- NOT READ (output limit) ---\n` +
+    `These files were not read, to keep this output under the tool output limit. ` +
+    `Read them with another batch-read call:\n` +
+    paths.map((path) => `- ${path}`).join("\n")
+  );
+}
+
 export default tool({
   description:
     "Read multiple files at once and return their contents. " +
-    "Use this instead of calling read multiple times sequentially.",
+    "Use this instead of calling read multiple times sequentially. " +
+    `Returns whole files, in order, up to about ${OUTPUT_LIMIT.bytes / 1024} KB and ${OUTPUT_LIMIT.lines} lines per call; ` +
+    "any files past that are listed as not read, so read them in another call.",
   args: {
     paths: tool.schema
       .array(tool.schema.string())
       .describe("Array of file paths (relative to project root) to read"),
   },
   async execute(args, context) {
-    const results: string[] = [];
+    const sections: string[] = [];
+    const notRead: string[] = [];
+    let bytes = 0;
+    let lines = 0;
     for (const filePath of args.paths) {
-      const fullPath = isAbsolute(filePath) ? filePath : join(context.directory, filePath);
-      try {
-        const content = await readFile(fullPath, "utf-8");
-        results.push(`--- ${filePath} ---\n${content}`);
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        results.push(`--- ${filePath} ---\nERROR: ${msg}`);
+      if (notRead.length > 0) {
+        notRead.push(filePath);
+        continue;
+      }
+      const section = await readSection(filePath, context.directory);
+      const sectionBytes =
+        Buffer.byteLength(section) + SECTION_SEPARATOR.length;
+      const sectionLines = section.split("\n").length + 1;
+      // The first file always goes in: alone, it is no worse than a plain read.
+      const fits =
+        sections.length === 0 ||
+        (bytes + sectionBytes <= OUTPUT_LIMIT.bytes &&
+          lines + sectionLines <= OUTPUT_LIMIT.lines);
+      if (!fits) {
+        notRead.push(filePath);
+        continue;
       }
+      sections.push(section);
+      bytes += sectionBytes;
+      lines += sectionLines;
     }
-    return results.join("\n\n");
+    if (notRead.length > 0) sections.push(notReadSection(notRead));
+    return sections.join(SECTION_SEPARATOR);
   },
 });

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");
     }