@blinkk/root-cms 2.4.10 → 2.5.2

package/dist/ai-OZY3JXDH.js

@@ -0,0 +1,19 @@
+import {
+  Chat,
+  ChatClient,
+  extractJsonFromResponse,
+  generateImage,
+  generatePublishMessage,
+  summarizeDiff,
+  translateString
+} from "./chunk-T5UK2H24.js";
+import "./chunk-MLKGABMK.js";
+export {
+  Chat,
+  ChatClient,
+  extractJsonFromResponse,
+  generateImage,
+  generatePublishMessage,
+  summarizeDiff,
+  translateString
+};

package/dist/app.js

@@ -1,10 +1,10 @@
 import {
   getServerVersion
-} from "./chunk-Y65VGJLE.js";
+} from "./chunk-QR62WMN3.js";
 import {
   getCollectionSchema,
   getProjectSchemas
-} from "./chunk-377TGNX2.js";
+} from "./chunk-MSJGHSR6.js";
 import "./chunk-MLKGABMK.js";
 
 // core/app.tsx

package/dist/{chunk-RYF3UTHQ.js → chunk-KDXHFMIH.js}

@@ -13,7 +13,7 @@ async function generateTypes() {
     rootConfig,
     modulePath
   );
-  const schemas = await project.getProjectSchemas();
+  const schemas = project.getProjectSchemas();
   const outputPath = path.resolve(rootDir, "root-cms.d.ts");
   await generateSchemaDts(outputPath, schemas);
   console.log("saved root-cms.d.ts!");
@@ -227,11 +227,11 @@ function fieldType(field, options) {
     if (field.types && Array.isArray(field.types)) {
       const unionTypes = [];
       field.types.forEach((schema) => {
-        let typeName;
+        let typeName = "";
         if (typeof schema === "string") {
           typeName = schema;
           return;
-        } else {
+        } else if (schema?.name) {
           typeName = schema.name;
         }
         if (!typeName) {

package/dist/chunk-MSJGHSR6.js

@@ -0,0 +1,172 @@
+// core/project.ts
+var SCHEMA_MODULES = import.meta.glob(
+  [
+    "/**/*.schema.ts",
+    "!/appengine/**/*.schema.ts",
+    "!/functions/**/*.schema.ts",
+    "!/gae/**/*.schema.ts"
+  ],
+  { eager: true }
+);
+function getProjectSchemas() {
+  const schemas = {};
+  for (const fileId in SCHEMA_MODULES) {
+    const schemaModule = SCHEMA_MODULES[fileId];
+    if (schemaModule.default) {
+      const resolved = resolveOneOfPatterns(schemaModule.default);
+      schemas[fileId] = resolved;
+    }
+  }
+  return schemas;
+}
+function resolveOneOfPatterns(schemaObj) {
+  const clone = structuredClone(schemaObj);
+  function handleField(field) {
+    if (field.type === "oneof") {
+      const oneOfField = field;
+      if (isSchemaPattern(oneOfField.types)) {
+        const resolved = resolveSchemaPattern(oneOfField.types);
+        oneOfField.types = resolved.names.map((name) => resolved.schemas[name]);
+      }
+    } else if (field.type === "object" && "fields" in field) {
+      (field.fields || []).forEach(handleField);
+    } else if (field.type === "array" && "of" in field && field.of) {
+      handleField(field.of);
+    }
+  }
+  (clone.fields || []).forEach(handleField);
+  return clone;
+}
+function getCollectionSchema(collectionId) {
+  if (!testValidCollectionId(collectionId)) {
+    throw new Error(`invalid collection id: ${collectionId}`);
+  }
+  const fileId = `/collections/${collectionId}.schema.ts`;
+  const module = SCHEMA_MODULES[fileId];
+  if (!module.default) {
+    console.warn(`collection schema not exported in: ${fileId}`);
+    return null;
+  }
+  const collection = module.default;
+  collection.id = collectionId;
+  return convertOneOfTypes(collection);
+}
+function testValidCollectionId(id) {
+  return /^[A-Za-z0-9_-]+$/.test(id);
+}
+function isSchemaPattern(value) {
+  return typeof value === "object" && value !== null && "_schemaPattern" in value && value._schemaPattern === true;
+}
+function buildSchemaNameMap() {
+  const nameMap = {};
+  for (const fileId in SCHEMA_MODULES) {
+    const module = SCHEMA_MODULES[fileId];
+    if (module.default && module.default.name) {
+      nameMap[module.default.name] = module.default;
+    }
+  }
+  return nameMap;
+}
+function globToRegex(pattern) {
+  const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{DOUBLE_STAR}}").replace(/\*/g, "[^/]*").replace(/\{\{DOUBLE_STAR\}\}/g, ".*");
+  return new RegExp(`^${regexStr}$`);
+}
+function resolveSchemaPattern(pattern) {
+  const regex = globToRegex(pattern.pattern);
+  const excludeSet = new Set(pattern.exclude || []);
+  const names = [];
+  const schemas = {};
+  for (const fileId in SCHEMA_MODULES) {
+    if (!regex.test(fileId)) {
+      continue;
+    }
+    const module = SCHEMA_MODULES[fileId];
+    if (!module.default || !module.default.name) {
+      continue;
+    }
+    const schemaName = module.default.name;
+    if (excludeSet.has(schemaName)) {
+      continue;
+    }
+    let schemaObj = module.default;
+    if (pattern.omitFields && pattern.omitFields.length > 0) {
+      const omitSet = new Set(pattern.omitFields);
+      schemaObj = {
+        ...schemaObj,
+        fields: schemaObj.fields.filter(
+          (f) => !omitSet.has(f.id || "")
+        )
+      };
+    }
+    names.push(schemaName);
+    schemas[schemaName] = schemaObj;
+  }
+  return { names, schemas };
+}
+function convertOneOfTypes(collection) {
+  const clone = structuredClone(collection);
+  const types = clone.types || {};
+  const schemaNameMap = buildSchemaNameMap();
+  function handleOneOfField(field) {
+    if (isSchemaPattern(field.types)) {
+      const resolved = resolveSchemaPattern(field.types);
+      for (const [name, schemaObj] of Object.entries(resolved.schemas)) {
+        if (!types[name]) {
+          types[name] = schemaObj;
+          if (schemaObj.fields) {
+            walk(schemaObj);
+          }
+        }
+      }
+      field.types = resolved.names;
+      return;
+    }
+    const names = [];
+    (field.types || []).forEach((sub) => {
+      if (typeof sub === "string") {
+        names.push(sub);
+        if (!types[sub] && schemaNameMap[sub]) {
+          const resolvedSchema = schemaNameMap[sub];
+          types[sub] = resolvedSchema;
+          if (resolvedSchema.fields) {
+            walk(resolvedSchema);
+          }
+        }
+        return;
+      }
+      if (sub.name) {
+        names.push(sub.name);
+        if (!types[sub.name]) {
+          types[sub.name] = sub;
+          if (sub.fields) {
+            walk(sub);
+          }
+        }
+      }
+    });
+    field.types = names;
+  }
+  function handleField(field) {
+    if (field.type === "oneof") {
+      handleOneOfField(field);
+    } else if (field.type === "object") {
+      walk(field);
+    } else if (field.type === "array" && field.of) {
+      handleField(field.of);
+    }
+  }
+  function walk(schema) {
+    const fields = schema?.fields || [];
+    fields.forEach(handleField);
+  }
+  walk(clone);
+  clone.types = types;
+  return clone;
+}
+
+export {
+  SCHEMA_MODULES,
+  getProjectSchemas,
+  resolveOneOfPatterns,
+  getCollectionSchema
+};

package/dist/{chunk-Y65VGJLE.js → chunk-QR62WMN3.js}

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "@blinkk/root-cms",
-  version: "2.4.10",
+  version: "2.5.2",
   author: "s@blinkk.com",
   license: "MIT",
   engines: {
@@ -166,7 +166,7 @@ var package_default = {
     yjs: "13.6.27"
   },
   peerDependencies: {
-    "@blinkk/root": "2.4.10",
+    "@blinkk/root": "2.5.2",
     "firebase-admin": ">=11",
     "firebase-functions": ">=4",
     preact: ">=10",

package/dist/{chunk-ZOEPOKGE.js → chunk-T5UK2H24.js}

@@ -14,6 +14,49 @@ var LEGACY_MODEL_RENAME = {
   "vertexai/gemini-2.0-pro": "gemini-2.0-pro"
 };
 async function summarizeDiff(cmsClient, options) {
+  const cmsPluginOptions = cmsClient.cmsPlugin.getConfig();
+  const firebaseConfig = cmsPluginOptions.firebaseConfig;
+  const model = "gemini-2.5-flash";
+  const ai = genkit({
+    plugins: [
+      vertexAI({
+        projectId: firebaseConfig.projectId,
+        location: firebaseConfig.location || "us-central1"
+      })
+    ]
+  });
+  const beforeJson = JSON.stringify(options.before ?? null, null, 2);
+  const afterJson = JSON.stringify(options.after ?? null, null, 2);
+  const systemPrompt = [
+    "Summarize CMS document changes in 2-4 bullet points.",
+    "Focus on content changes only. Ignore metadata like timestamps.",
+    'If no meaningful changes, say "No significant changes."'
+  ].join("\n");
+  const diffPrompt = [
+    "Before:",
+    beforeJson,
+    "",
+    "After:",
+    afterJson,
+    "",
+    "What changed?"
+  ].join("\n");
+  const res = await generate(ai, model, {
+    messages: [
+      {
+        role: "system",
+        content: [{ text: systemPrompt }]
+      }
+    ],
+    prompt: [{ text: diffPrompt }],
+    config: {
+      // Respond more quickly with less creativity.
+      temperature: 0.3
+    }
+  });
+  return res.text?.trim() || "";
+}
+async function generatePublishMessage(cmsClient, options) {
   const cmsPluginOptions = cmsClient.cmsPlugin.getConfig();
   const firebaseConfig = cmsPluginOptions.firebaseConfig;
   const model = (typeof cmsPluginOptions.experiments?.ai === "object" ? cmsPluginOptions.experiments.ai.model : void 0) || DEFAULT_MODEL;
@@ -28,10 +71,13 @@ async function summarizeDiff(cmsClient, options) {
   const beforeJson = JSON.stringify(options.before ?? null, null, 2);
   const afterJson = JSON.stringify(options.after ?? null, null, 2);
   const systemPrompt = [
-    "You are an assistant that summarizes changes made to CMS documents stored as JSON.",
-    "Provide a concise description of the most important updates using short bullet points.",
-    'If there are no meaningful differences, respond with "No significant changes."',
-    `Focus on just the content changes, ignore insignificant changes to richtext blocks and structure, such as updates to the richtext block's "timestamp" and "version" fields.`
+    "You are an assistant that generates concise commit-style messages for CMS document changes.",
+    "Generate a single short sentence (maximum 60 characters) describing the most important change.",
+    'Use imperative mood like "Add feature" or "Update content" or "Fix typo".',
+    "Focus on the key content change, ignore structural metadata changes.",
+    "Do not use punctuation at the end.",
+    'Examples: "Add new hero image", "Update pricing details", "Fix typo in headline"',
+    "Include "
   ].join("\n");
   const diffPrompt = [
     "Previous version JSON:",
@@ -44,7 +90,7 @@ async function summarizeDiff(cmsClient, options) {
     afterJson,
     "```",
     "",
-    "Summarize the differences between the two payloads."
+    "Generate a commit message for these changes."
   ].join("\n");
   const res = await generate(ai, model, {
     messages: [
@@ -285,10 +331,89 @@ var ChatClient = class {
 function cleanModelName(model) {
   return LEGACY_MODEL_RENAME[model] || model;
 }
+function extractJsonFromResponse(responseText) {
+  let jsonText = responseText.trim();
+  if (jsonText.startsWith("```")) {
+    const lines = jsonText.split("\n");
+    jsonText = lines.slice(1, -1).join("\n");
+    if (jsonText.startsWith("json")) {
+      jsonText = jsonText.substring(4).trim();
+    }
+  }
+  return jsonText;
+}
+async function translateString(cmsClient, options) {
+  const cmsPluginOptions = cmsClient.cmsPlugin.getConfig();
+  const firebaseConfig = cmsPluginOptions.firebaseConfig;
+  const model = (typeof cmsPluginOptions.experiments?.ai === "object" ? cmsPluginOptions.experiments.ai.model : void 0) || DEFAULT_MODEL;
+  const ai = genkit({
+    plugins: [
+      vertexAI({
+        projectId: firebaseConfig.projectId,
+        location: firebaseConfig.location || "us-central1"
+      })
+    ]
+  });
+  const systemPrompt = [
+    "You are a professional translator assistant.",
+    "Translate the given source text into the requested target languages.",
+    "Maintain the tone, style, and intent of the original text.",
+    "Return ONLY a valid JSON object with locale codes as keys and translations as values.",
+    "Do not include any markdown formatting, code blocks, or explanatory text."
+  ].join("\n");
+  const userPromptParts = [
+    `Source text: "${options.sourceText}"`,
+    ""
+  ];
+  if (options.description) {
+    userPromptParts.push(`Context/Description: ${options.description}`, "");
+  }
+  if (options.existingTranslations && Object.keys(options.existingTranslations).length > 0) {
+    userPromptParts.push("Existing translations for reference:");
+    Object.entries(options.existingTranslations).forEach(
+      ([locale, translation]) => {
+        if (translation) {
+          userPromptParts.push(`- ${locale}: "${translation}"`);
+        }
+      }
+    );
+    userPromptParts.push("");
+  }
+  userPromptParts.push(
+    `Target locales: ${options.targetLocales.join(", ")}`,
+    "",
+    "Provide translations as a JSON object with locale codes as keys."
+  );
+  const userPrompt = userPromptParts.join("\n");
+  const res = await generate(ai, model, {
+    messages: [
+      {
+        role: "system",
+        content: [{ text: systemPrompt }]
+      },
+      {
+        role: "user",
+        content: [{ text: userPrompt }]
+      }
+    ]
+  });
+  const responseText = res.text || "{}";
+  const jsonText = extractJsonFromResponse(responseText);
+  try {
+    const translations = JSON.parse(jsonText);
+    return translations;
+  } catch (err) {
+    console.error("Failed to parse AI translation response:", responseText);
+    throw new Error("Invalid response format from AI translation");
+  }
+}
 
 export {
   summarizeDiff,
+  generatePublishMessage,
   generateImage,
   Chat,
-  ChatClient
+  ChatClient,
+  extractJsonFromResponse,
+  translateString
 };