@blinkk/root-cms 3.0.1-beta.3 → 3.0.1-beta.5

package/dist/app.js

@@ -1,8 +1,9 @@
 import {
   getServerVersion,
   serializeAiConfig
-} from "./chunk-NXEXOHBD.js";
-import "./chunk-CRK7N6RR.js";
+} from "./chunk-5CZBPART.js";
+import "./chunk-C245C557.js";
+import "./chunk-2BSW7SIH.js";
 import {
   getCollectionSchema,
   getProjectSchemas

package/dist/{chunk-F4SODS5S.js → chunk-2BSW7SIH.js}

@@ -1,7 +1,3 @@
-import {
-  validateFields
-} from "./chunk-CRK7N6RR.js";
-
 // core/client.ts
 import crypto from "crypto";
 import {
@@ -362,6 +358,301 @@ function buildTranslationsLocaleDocDbPath(options) {
   ).replace("{mode}", options.mode).replace("{id}", normalizeSlug(options.id)).replace("{locale}", options.locale);
 }
 
+// core/validation.ts
+function validateFields(fieldsData, schema) {
+  if (fieldsData === null || fieldsData === void 0) {
+    return [];
+  }
+  if (typeof fieldsData !== "object" || Array.isArray(fieldsData)) {
+    return [
+      {
+        path: "",
+        message: "Expected object for fields data",
+        expected: "object",
+        received: getType(fieldsData)
+      }
+    ];
+  }
+  const errors = [];
+  for (const field of schema.fields) {
+    if (!field.id) {
+      continue;
+    }
+    if (!(field.id in fieldsData)) {
+      continue;
+    }
+    const value = fieldsData[field.id];
+    errors.push(...validateValue(value, field, field.id));
+  }
+  return errors;
+}
+function validateValue(value, field, path) {
+  if (value === void 0) {
+    return [];
+  }
+  switch (field.type) {
+    case "string":
+    case "select":
+      if (typeof value !== "string") {
+        return [createError(path, "string", value)];
+      }
+      return [];
+    case "number":
+      if (typeof value !== "number") {
+        return [createError(path, "number", value)];
+      }
+      if (isNaN(value)) {
+        return [createError(path, "number", value)];
+      }
+      return [];
+    case "boolean":
+      if (typeof value !== "boolean") {
+        return [createError(path, "boolean", value)];
+      }
+      return [];
+    case "date":
+    case "datetime": {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return [createError(path, "object", value)];
+      }
+      const errors = [];
+      const seconds = value.seconds;
+      const nanoseconds = value.nanoseconds;
+      if (seconds === void 0) {
+        errors.push({
+          path: `${path}.seconds`,
+          message: "Required",
+          expected: "number",
+          received: "undefined"
+        });
+      } else if (typeof seconds !== "number") {
+        errors.push(createError(`${path}.seconds`, "number", seconds));
+      }
+      if (nanoseconds === void 0) {
+        errors.push({
+          path: `${path}.nanoseconds`,
+          message: "Required",
+          expected: "number",
+          received: "undefined"
+        });
+      } else if (typeof nanoseconds !== "number") {
+        errors.push(createError(`${path}.nanoseconds`, "number", nanoseconds));
+      }
+      return errors;
+    }
+    case "multiselect":
+      if (!Array.isArray(value)) {
+        return [createError(path, "array", value)];
+      }
+      return value.flatMap((item, index) => {
+        if (typeof item !== "string") {
+          return [createError(`${path}.${index}`, "string", item)];
+        }
+        return [];
+      });
+    case "image":
+    case "file": {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return [createError(path, "object", value)];
+      }
+      const errors = [];
+      if (value.src === void 0) {
+        errors.push({
+          path: `${path}.src`,
+          message: "Required",
+          expected: "string",
+          received: "undefined"
+        });
+      } else if (typeof value.src !== "string") {
+        errors.push(createError(`${path}.src`, "string", value.src));
+      }
+      if (value.alt !== void 0 && typeof value.alt !== "string") {
+        errors.push(createError(`${path}.alt`, "string", value.alt));
+      }
+      return errors;
+    }
+    case "object": {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return [createError(path, "object", value)];
+      }
+      const objectField = field;
+      const errors = [];
+      for (const nestedField of objectField.fields) {
+        if (!nestedField.id || !(nestedField.id in value)) {
+          continue;
+        }
+        errors.push(
+          ...validateValue(
+            value[nestedField.id],
+            nestedField,
+            `${path}.${nestedField.id}`
+          )
+        );
+      }
+      return errors;
+    }
+    case "array": {
+      if (!Array.isArray(value)) {
+        return [createError(path, "array", value)];
+      }
+      const arrayField = field;
+      const itemField = arrayField.of;
+      return value.flatMap((item, index) => {
+        return validateValue(item, itemField, `${path}.${index}`);
+      });
+    }
+    case "oneof": {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return [createError(path, "object", value)];
+      }
+      const oneOfField = field;
+      const typeName = value._type;
+      const typeMap = /* @__PURE__ */ new Map();
+      const typeNames = [];
+      for (const type of oneOfField.types) {
+        if (typeof type === "string") {
+          typeNames.push(type);
+          continue;
+        }
+        typeMap.set(type.name, type);
+        typeNames.push(type.name);
+      }
+      if (!typeNames.includes(typeName)) {
+        const expectedStr = typeNames.map((t) => `'${t}'`).join(" | ");
+        return [
+          {
+            path: `${path}._type`,
+            message: `Invalid discriminator value. Expected ${expectedStr}`,
+            expected: "valid discriminator value",
+            received: typeName
+          }
+        ];
+      }
+      const matchedSchema = typeMap.get(typeName);
+      if (!matchedSchema) {
+        return [];
+      }
+      const errors = [];
+      for (const nestedField of matchedSchema.fields) {
+        if (!nestedField.id || !(nestedField.id in value)) {
+          continue;
+        }
+        errors.push(
+          ...validateValue(
+            value[nestedField.id],
+            nestedField,
+            `${path}.${nestedField.id}`
+          )
+        );
+      }
+      return errors;
+    }
+    case "richtext": {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return [createError(path, "object", value)];
+      }
+      const errors = [];
+      if (value.blocks === void 0) {
+        errors.push({
+          path: `${path}.blocks`,
+          message: "Required",
+          expected: "array",
+          received: "undefined"
+        });
+      } else if (!Array.isArray(value.blocks)) {
+        errors.push(createError(`${path}.blocks`, "array", value.blocks));
+      } else {
+        value.blocks.forEach((block, index) => {
+          if (typeof block !== "object" || block === null) {
+            errors.push(
+              createError(`${path}.blocks.${index}`, "object", block)
+            );
+            return;
+          }
+          if (block.type === void 0) {
+            errors.push({
+              path: `${path}.blocks.${index}.type`,
+              message: "Required",
+              expected: "string",
+              received: "undefined"
+            });
+          } else if (typeof block.type !== "string") {
+            errors.push(
+              createError(`${path}.blocks.${index}.type`, "string", block.type)
+            );
+          }
+        });
+      }
+      return errors;
+    }
+    case "reference": {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return [createError(path, "object", value)];
+      }
+      const errors = [];
+      const requiredFields = ["id", "collection", "slug"];
+      for (const req of requiredFields) {
+        if (value[req] === void 0) {
+          errors.push({
+            path: `${path}.${req}`,
+            message: "Required",
+            expected: "string",
+            received: "undefined"
+          });
+        } else if (typeof value[req] !== "string") {
+          errors.push(createError(`${path}.${req}`, "string", value[req]));
+        }
+      }
+      return errors;
+    }
+    case "references": {
+      if (!Array.isArray(value)) {
+        return [createError(path, "array", value)];
+      }
+      return value.flatMap((item, index) => {
+        if (typeof item !== "object" || item === null || Array.isArray(item)) {
+          return [createError(`${path}.${index}`, "object", item)];
+        }
+        const errors = [];
+        const requiredFields = ["id", "collection", "slug"];
+        for (const req of requiredFields) {
+          if (item[req] === void 0) {
+            errors.push({
+              path: `${path}.${index}.${req}`,
+              message: "Required",
+              expected: "string",
+              received: "undefined"
+            });
+          } else if (typeof item[req] !== "string") {
+            errors.push(
+              createError(`${path}.${index}.${req}`, "string", item[req])
+            );
+          }
+        }
+        return errors;
+      });
+    }
+    default:
+      console.warn(`Unknown field type: ${field.type}`);
+      return [];
+  }
+}
+function getType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "number" && Number.isNaN(value)) return "nan";
+  return typeof value;
+}
+function createError(path, expected, receivedValue) {
+  const received = getType(receivedValue);
+  return {
+    path,
+    message: `Expected ${expected}, received ${received}`,
+    expected,
+    received
+  };
+}
+
 // core/values.ts
 function setValueAtPath(obj, path, value) {
   const keys = path.split(".");

package/dist/{chunk-NXEXOHBD.js → chunk-5CZBPART.js}

@@ -1,3 +1,10 @@
+import {
+  SearchIndexService
+} from "./chunk-C245C557.js";
+import {
+  normalizeSlug
+} from "./chunk-2BSW7SIH.js";
+
 // core/ai.ts
 import crypto from "crypto";
 import { promises as fs } from "fs";
@@ -18,6 +25,40 @@ import { Timestamp } from "firebase-admin/firestore";
 // core/ai-tools.ts
 import { tool } from "ai";
 import { z } from "zod";
+
+// shared/marshal.ts
+function isArrayObject(data) {
+  return data !== null && typeof data === "object" && !Array.isArray(data) && Array.isArray(data._array);
+}
+function unmarshalData(data, options) {
+  if (data === null || data === void 0) {
+    return data;
+  }
+  if (typeof data !== "object") {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => unmarshalData(item, options));
+  }
+  if (options?.isTimestamp?.(data)) {
+    return options.timestampToValue ? options.timestampToValue(data) : data;
+  }
+  if (typeof data.toMillis === "function") {
+    return data.toMillis();
+  }
+  if (isArrayObject(data)) {
+    return data._array.map(
+      (key) => unmarshalData(data[key] ?? {}, options)
+    );
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(data)) {
+    out[k] = unmarshalData(v, options);
+  }
+  return out;
+}
+
+// core/ai-tools.ts
 var READ_ONLY_CMS_TOOL_NAMES = [
   "collections_list",
   "docs_list",
@@ -27,8 +68,8 @@ var READ_ONLY_CMS_TOOL_NAMES = [
   "doc_listVersions",
   "schema_get"
 ];
-function createReadOnlyCmsTools() {
-  const all = createCmsTools();
+function createReadOnlyCmsTools(ctx) {
+  const all = createCmsTools(ctx);
   const out = {};
   for (const name of READ_ONLY_CMS_TOOL_NAMES) {
     if (all[name]) {
@@ -37,11 +78,21 @@ function createReadOnlyCmsTools() {
   }
   return out;
 }
-function createCmsTools() {
+function createCmsTools(ctx) {
   return {
     collections_list: tool({
       description: "List all CMS collections defined in the project. Returns each collection id along with optional name/description metadata.",
-      inputSchema: z.object({})
+      inputSchema: z.object({}),
+      execute: async () => {
+        const collections = await ctx.loadAllCollections();
+        return {
+          collections: Object.entries(collections).map(([id, meta]) => ({
+            id,
+            name: meta.name,
+            description: meta.description
+          }))
+        };
+      }
     }),
     docs_list: tool({
       description: "List documents inside a CMS collection. Returns up to `limit` docs (default 25, max 100). Use this to explore content before reading individual docs.",
@@ -49,14 +100,32 @@ function createCmsTools() {
         collectionId: z.string().describe('Collection id, e.g. "Pages" or "BlogPosts".'),
         mode: z.enum(["draft", "published"]).default("draft").describe("Whether to read draft or published versions."),
         limit: z.number().int().min(1).max(100).default(25)
-      })
+      }),
+      execute: async ({ collectionId, mode = "draft", limit = 25 }) => {
+        const max = clampInt(limit, 1, 100, 25);
+        const result = await ctx.cmsClient.listDocs(collectionId, {
+          mode,
+          limit: max
+        });
+        return {
+          docs: result.docs.map((d) => ({
+            id: d.id,
+            slug: d.slug,
+            sys: unmarshalSys(d.sys)
+          }))
+        };
+      }
     }),
     docs_search: tool({
       description: "Run a full-text search across all indexed CMS docs. Returns the top matching doc ids ordered by relevance.",
       inputSchema: z.object({
         query: z.string().min(1),
         limit: z.number().int().min(1).max(50).default(10)
-      })
+      }),
+      execute: async ({ query, limit = 10 }) => {
+        const max = clampInt(limit, 1, 50, 10);
+        return await ctx.search(query, { limit: max });
+      }
     }),
     doc_get: tool({
       description: "Read a single CMS document. Returns the doc fields plus system metadata. Use this when you need the full content of a doc.",
@@ -65,7 +134,24 @@ function createCmsTools() {
           'Full doc id in the form "Collection/slug" (e.g. "Pages/home").'
         ),
         mode: z.enum(["draft", "published"]).default("draft")
-      })
+      }),
+      execute: async ({ docId, mode = "draft" }) => {
+        const { collection, slug } = parseDocId(docId);
+        const raw = await ctx.cmsClient.getRawDoc(collection, slug, { mode });
+        if (!raw) {
+          return { found: false };
+        }
+        return {
+          found: true,
+          doc: {
+            id: raw.id,
+            collection: raw.collection,
+            slug: raw.slug,
+            sys: unmarshalSys(raw.sys),
+            fields: unmarshalFields(raw.fields)
+          }
+        };
+      }
     }),
     doc_getVersion: tool({
       description: 'Read a specific version of a CMS document. Use versionId "draft" or "published" for the current draft/published state, or a numeric timestamp for a historical version (from `doc_listVersions`).',
@@ -76,7 +162,33 @@ function createCmsTools() {
         versionId: z.string().describe(
           'Version identifier: "draft", "published", or a numeric timestamp.'
         )
-      })
+      }),
+      execute: async ({ docId, versionId }) => {
+        const { collection, slug } = parseDocId(docId);
+        let path2;
+        if (versionId === "draft") {
+          path2 = `Projects/${ctx.cmsClient.projectId}/Collections/${collection}/Drafts/${slug}`;
+        } else if (versionId === "published") {
+          path2 = `Projects/${ctx.cmsClient.projectId}/Collections/${collection}/Published/${slug}`;
+        } else {
+          path2 = `Projects/${ctx.cmsClient.projectId}/Collections/${collection}/Drafts/${slug}/Versions/${versionId}`;
+        }
+        const snap = await ctx.cmsClient.db.doc(path2).get();
+        if (!snap.exists) {
+          return { found: false };
+        }
+        const raw = snap.data();
+        return {
+          found: true,
+          doc: {
+            id: raw.id,
+            collection: raw.collection,
+            slug: raw.slug,
+            sys: unmarshalSys(raw.sys),
+            fields: unmarshalFields(raw.fields)
+          }
+        };
+      }
     }),
     doc_set: tool({
       description: "Replace the entire draft fields payload of a CMS document. Pass the full JSON object that should become the new draft contents \u2014 any fields omitted will be removed. The payload is validated against the collection schema and the call is rejected on validation errors. Prefer `doc_updateField` for targeted edits. Only writes the draft version; users must publish separately. Always confirm with the user before calling.",
@@ -128,7 +240,24 @@ function createCmsTools() {
           'Full doc id in the form "Collection/slug" (e.g. "Pages/home").'
         ),
         limit: z.number().int().min(1).max(50).default(10)
-      })
+      }),
+      execute: async ({ docId, limit = 10 }) => {
+        const { collection, slug } = parseDocId(docId);
+        const max = clampInt(limit, 1, 50, 10);
+        const path2 = `Projects/${ctx.cmsClient.projectId}/Collections/${collection}/Drafts/${slug}/Versions`;
+        const snap = await ctx.cmsClient.db.collection(path2).orderBy("sys.modifiedAt", "desc").limit(max).get();
+        return {
+          versions: snap.docs.map((d) => {
+            const data = d.data();
+            return {
+              versionId: d.id,
+              sys: unmarshalSys(data.sys),
+              tags: data.tags || [],
+              publishMessage: data.publishMessage
+            };
+          })
+        };
+      }
     }),
     doc_translateField: tool({
       description: "Translate a text value into one or more target locales using AI. Returns the translated strings keyed by locale. Use this to help with localization workflows.",
@@ -146,10 +275,63 @@ function createCmsTools() {
       description: "Get the field schema for a CMS collection. Returns the full field definitions including types, labels, and validation rules. Use this to understand what fields a collection supports before creating or editing docs.",
       inputSchema: z.object({
         collectionId: z.string().describe('Collection id, e.g. "Pages" or "BlogPosts".')
-      })
+      }),
+      execute: async ({ collectionId }) => {
+        const schema = await ctx.loadCollection(collectionId);
+        if (!schema) {
+          return { found: false, collectionId };
+        }
+        return {
+          found: true,
+          collectionId,
+          fields: simplifyFields(schema.fields || [])
+        };
+      }
     })
   };
 }
+function parseDocId(docId) {
+  const idx = docId.indexOf("/");
+  if (idx <= 0 || idx === docId.length - 1) {
+    throw new Error(`invalid docId: "${docId}" (expected "Collection/slug")`);
+  }
+  return {
+    collection: docId.slice(0, idx),
+    slug: normalizeSlug(docId.slice(idx + 1))
+  };
+}
+function clampInt(value, min, max, fallback) {
+  const n = Number.isFinite(value) ? Math.trunc(value) : fallback;
+  return Math.min(Math.max(n, min), max);
+}
+function unmarshalSys(sys) {
+  return unmarshalData(sys ?? {});
+}
+function unmarshalFields(fields) {
+  return unmarshalData(fields ?? {});
+}
+function simplifyFields(fields) {
+  return fields.map((f) => {
+    const out = { id: f.id, type: f.type };
+    if (f.label) out.label = f.label;
+    if (f.description) out.description = f.description;
+    if (f.required) out.required = true;
+    if (f.translate) out.translate = true;
+    if (f.options) out.options = f.options;
+    if (f.type === "object" && f.fields) {
+      out.fields = simplifyFields(f.fields);
+    }
+    if (f.type === "array" && f.of) {
+      out.of = simplifyFields([f.of])[0];
+    }
+    if (f.type === "oneof" && f.types) {
+      out.types = f.types.map(
+        (t) => typeof t === "string" ? t : { id: t.id, fields: simplifyFields(t.fields || []) }
+      );
+    }
+    return out;
+  });
+}
 
 // core/ai.ts
 var ROOT_MD_FILENAME = "ROOT.md";
@@ -424,6 +606,25 @@ async function generateChatTitle(model, messages) {
   }
   return fallback;
 }
+function buildCmsToolContext(options) {
+  let searchService = null;
+  return {
+    rootConfig: options.rootConfig,
+    cmsClient: options.cmsClient,
+    user: options.user,
+    loadCollection: options.loadCollection,
+    loadAllCollections: options.loadAllCollections,
+    search: async (query, opts) => {
+      if (!searchService) {
+        searchService = new SearchIndexService(
+          options.rootConfig,
+          options.loadCollection
+        );
+      }
+      return await searchService.search(query, opts);
+    }
+  };
+}
 function buildExecutionModePrompt(mode) {
   const common = [
     "Root AI execution workflow:",
@@ -473,10 +674,19 @@ async function runChatStream(options) {
     cmsClient,
     user,
     chatId,
-    executionMode = "approve"
+    executionMode = "approve",
+    loadCollection,
+    loadAllCollections
   } = options;
   const languageModel = resolveLanguageModel(model);
-  const tools = model.capabilities?.tools === false ? {} : executionMode === "read" || executionMode === "suggest" ? createReadOnlyCmsTools() : createCmsTools();
+  const toolContext = buildCmsToolContext({
+    rootConfig,
+    cmsClient,
+    user,
+    loadCollection,
+    loadAllCollections
+  });
+  const tools = model.capabilities?.tools === false ? {} : executionMode === "read" || executionMode === "suggest" ? createReadOnlyCmsTools(toolContext) : createCmsTools(toolContext);
   const basePrompt = config.systemPrompt || [
     "You are an assistant embedded in the Root CMS admin UI.",
     "Help the user explore and edit content, answer questions about",
@@ -519,9 +729,26 @@ async function runChatStream(options) {
   });
 }
 async function runEditObjectStream(options) {
-  const { rootConfig, model, config, messages, editData } = options;
+  const {
+    rootConfig,
+    cmsClient,
+    user,
+    model,
+    config,
+    messages,
+    editData,
+    loadCollection,
+    loadAllCollections
+  } = options;
   const languageModel = resolveLanguageModel(model);
-  const tools = model.capabilities?.tools === false ? {} : createReadOnlyCmsTools();
+  const toolContext = buildCmsToolContext({
+    rootConfig,
+    cmsClient,
+    user,
+    loadCollection,
+    loadAllCollections
+  });
+  const tools = model.capabilities?.tools === false ? {} : createReadOnlyCmsTools(toolContext);
   const editPromptText = (await import("./edit-XX3LAGK6.js")).default;
   const promptParts = [
     stripLegacyEditOutputSpec(editPromptText),
@@ -776,7 +1003,7 @@ function extractJsonFromResponse(responseText) {
 // package.json
 var package_default = {
   name: "@blinkk/root-cms",
-  version: "3.0.1-beta.3",
+  version: "3.0.1-beta.5",
   author: "s@blinkk.com",
   license: "MIT",
   engines: {
@@ -945,7 +1172,7 @@ var package_default = {
     yjs: "13.6.27"
   },
   peerDependencies: {
-    "@blinkk/root": "3.0.1-beta.3",
+    "@blinkk/root": "3.0.1-beta.5",
     "firebase-admin": ">=11",
     "firebase-functions": ">=4"
   },