@paroicms/site-generator-plugin 0.27.8 → 0.28.0

package/backend/dist/generator/fake-content-generator/fill-taxonomy-fields.js

@@ -1,6 +1,7 @@
+import { encodeLNodeId, } from "@paroicms/public-anywhere-lib";
 export async function updateLNodesWithTaxonomies(ctx, options) {
-    const { service } = ctx;
-    const { siteSchema, idPicker, fqdn } = options;
+    const { siteSchema, siteConnector } = ctx;
+    const { idPicker } = options;
     const { nodeTypes } = siteSchema;
     for (const nodeType of Object.values(nodeTypes)) {
         const labelingFields = nodeType.fields?.filter((f) => f.dataType === "labeling");
@@ -8,19 +9,20 @@ export async function updateLNodesWithTaxonomies(ctx, options) {
             continue;
         await updateLabelingFields(ctx, {
             idPicker,
-            fqdn,
             nodeType,
             labelingFields,
-        }, service);
+        }, siteConnector);
     }
 }
-async function updateLabelingFields(ctx, options, service) {
-    const { fqdn, nodeType, labelingFields, idPicker } = options;
+async function updateLabelingFields(ctx, options, siteConnector) {
+    const { nodeType, labelingFields, idPicker } = options;
     if (nodeType.kind !== "document" && nodeType.kind !== "part")
         return;
     const nodeIds = idPicker.pickNodeIds({ typeName: nodeType.typeName });
+    // Labeling fields are not localized, so use default language
+    const defaultLanguage = ctx.siteSchema.languages[0];
     for (const nodeId of nodeIds) {
-        const fieldValues = [];
+        const fieldValues = {};
         for (const field of labelingFields) {
             const taxonomyIds = idPicker.pickNodeIds({ typeName: field.taxonomy });
             if (taxonomyIds.length !== 1) {
@@ -34,24 +36,13 @@ async function updateLabelingFields(ctx, options, service) {
             const termNodeIds = idPicker.pickNodeIds({ parentNodeId: taxonomyNodeId }, max);
             if (termNodeIds.length === 0)
                 continue;
-            fieldValues.push([
-                field.name,
-                {
-                    dataType: "labeling",
-                    localized: false,
-                    value: { t: termNodeIds },
-                },
-            ]);
+            const labelingValue = { t: termNodeIds };
+            fieldValues[field.name] = labelingValue;
         }
-        if (fieldValues.length === 0)
+        if (Object.keys(fieldValues).length === 0)
             continue;
-        await service.connector.updateNodeContent(fqdn, {
-            nodeId,
-            content: {
-                kind: nodeType.kind,
-                typeName: nodeType.typeName,
-                fields: Object.fromEntries(fieldValues),
-            },
-        });
+        // Use updateFields with the default language since labeling is not localized
+        const lNodeId = encodeLNodeId({ nodeId, language: defaultLanguage });
+        await siteConnector.updateFields(lNodeId, fieldValues);
     }
 }

package/backend/dist/generator/fake-content-generator/generate-fake-content.js

@@ -12,13 +12,14 @@ export async function generateFieldSetContent(ctx, options, report) {
     return list[0];
 }
 export async function generateMultipleFieldSetContents(ctx, options, report) {
-    const { siteSchema, nodeType, documentType, schemaI18n, count, withTitle, tolerateErrors, llmTaskName, } = options;
+    const { siteSchema, nodeType, documentType, schemaI18n, count, withTitle, tolerateErrors, llmTaskName, isTaxonomyTerm, } = options;
     if (nodeType.kind === "site")
         throw new Error("Cannot generate content for site node type");
     // for a document, the LLM is best at generating the title, so we ask for it and remove it later
     const skipTitle = nodeType.kind === "document" && !withTitle;
+    const titleTagDescription = isTaxonomyTerm ? "Term Name Here" : "Write the title here";
     const outputTags = withTitle || skipTitle
-        ? [{ tagName: "title", key: "title", format: "text", tagDescription: "Write the title here" }]
+        ? [{ tagName: "title", key: "title", format: "text", tagDescription: titleTagDescription }]
         : [];
     if (nodeType.fields) {
         outputTags.push(...nodeType.fields.map(toFakeContentOutputTag).filter(isDef));
@@ -50,6 +51,7 @@ export async function generateMultipleFieldSetContents(ctx, options, report) {
             documentDescription,
             siteTheme,
             language,
+            isTaxonomyTerm,
         }, outputTags, { tolerateErrors, llmTaskName })
         : undefined;
     if (skipTitle && output) {

package/backend/dist/generator/fake-content-generator/invoke-generate-fake-content.js

@@ -8,13 +8,14 @@ import { buildPromptTemplate } from "../lib/prompt-template.js";
 const singlePromptTemplate = buildPromptTemplate(await readPromptFile("generate-fake-content-single.md"));
 const multipleDocumentsPromptTemplate = buildPromptTemplate(await readPromptFile("generate-fake-content-multiple-documents.md"));
 const multiplePartsPromptTemplate = buildPromptTemplate(await readPromptFile("generate-fake-content-multiple-parts.md"));
+const multipleTermsPromptTemplate = buildPromptTemplate(await readPromptFile("generate-fake-content-multiple-terms.md"));
 export async function invokeGenerateFakeContent(ctx, input, outputTags, options) {
     const { language, typeKind } = input;
     const single = input.count === 1;
     const llmTaskName = `fake-content-${options.llmTaskName}${single ? "" : `-${input.count}`}`;
     const tagAndDescriptions = outputTags
         .map(({ tagName, tagDescription }) => `<${tagName}>${tagDescription}</${tagName}>`)
-        .join("\n\n");
+        .join("\n");
     // Call LLM in batch mode
     const maxBatchSize = 15;
     const batchInputs = [];
@@ -45,7 +46,9 @@ export async function invokeGenerateFakeContent(ctx, input, outputTags, options)
         const promptTemplate = single
             ? singlePromptTemplate
             : typeKind === "document"
-                ? multipleDocumentsPromptTemplate
+                ? input.isTaxonomyTerm
+                    ? multipleTermsPromptTemplate
+                    : multipleDocumentsPromptTemplate
                 : multiplePartsPromptTemplate;
         // Process batch inputs
         const messages = batchInputs.map(promptTemplate);
@@ -59,7 +62,12 @@ export async function invokeGenerateFakeContent(ctx, input, outputTags, options)
     }
     const results = [];
     for (const llmMessageContent of llmOutput.outputs) {
-        const list = parseLlmResponseAsList(llmMessageContent, outputTags, options);
+        const list = parseLlmResponseAsList(llmMessageContent, outputTags, {
+            ...options,
+            titleFromMarkdownHeading: outputTags.some((tag) => tag.key === "title")
+                ? "title"
+                : undefined,
+        });
         results.push(...list.map((fields) => Object.fromEntries(Object.entries(fields).map(([fieldName, value]) => [fieldName, { [language]: value }]))));
     }
     return { contents: results, llmReport: llmOutput.llmReport };

package/backend/dist/generator/lib/create-prompt.js

@@ -1,9 +1,9 @@
-import { jtDir } from "@paroicms/public-server-lib";
+import { docsDir, jtDir } from "@paroicms/public-server-lib";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { projectDir } from "../../context.js";
 import { buildPromptTemplate } from "./prompt-template.js";
-const contextContent = await readPromptFile("0-context.md");
+const contextContent = await readFile(join(docsDir, "introduction-to-paroicms.md"), "utf-8");
 const siteSchemaTsDefs = await readFile(join(jtDir, "site-schema-json-types.d.ts"), "utf-8");
 const predefinedFields = JSON.parse(await readPromptFile("predefined-fields.json"));
 export async function createPromptTemplate(options) {

package/backend/dist/generator/lib/parse-llm-response.js

@@ -19,22 +19,38 @@ export function parseLlmResponseAsProperties(llmResponse, outputTags) {
     return resultObj;
 }
 export function parseLlmResponseAsList(llmResponse, outputTags, options = {}) {
-    const { tolerateErrors } = options;
+    const { tolerateErrors, titleFromMarkdownHeading } = options;
     const rawTags = parseLlmRawTags(llmResponse, outputTags.map((tag) => tag.tagName), options);
     if (rawTags.length === 0)
         return [];
     const outputTagMap = new Map(outputTags.map((tag) => [tag.tagName, tag]));
+    const titleOutputTag = titleFromMarkdownHeading
+        ? outputTags.find((tag) => tag.key === titleFromMarkdownHeading)
+        : undefined;
     const result = [];
     let current = {};
-    for (const rawTag of rawTags) {
+    let currentItemStartPosition;
+    let previousItemEndPosition = 0;
+    for (let tagIndex = 0; tagIndex < rawTags.length; ++tagIndex) {
+        const rawTag = rawTags[tagIndex];
         const outputTag = outputTagMap.get(rawTag.tagName);
         if (!outputTag)
             throw new Error(`Unexpected output tag "${rawTag.tagName}"`); // it's a real bug
-        if (rawTag.tagName in current) {
-            const rawTag = ensureProperties(current, outputTags, options);
-            if (rawTag) {
-                result.push(rawTag);
+        // Track start position of current item (first tag we see for this item)
+        if (currentItemStartPosition === undefined) {
+            currentItemStartPosition = rawTag.startPosition;
+        }
+        if (outputTag.key in current) {
+            // We're starting a new item - try to complete the previous one
+            const completedItem = tryCompleteItem(current, outputTags, titleOutputTag, llmResponse, previousItemEndPosition, currentItemStartPosition, options);
+            if (completedItem) {
+                result.push(completedItem);
             }
+            // Update end position for next gap calculation:
+            // The gap for the next item starts where this tag starts (not where the previous item started)
+            // This way, the Markdown heading before this tag can be found
+            previousItemEndPosition = currentItemStartPosition;
+            currentItemStartPosition = rawTag.startPosition;
             current = {};
         }
         if (rawTag.content.trim() === "") {
@@ -44,21 +60,37 @@ export function parseLlmResponseAsList(llmResponse, outputTags, options = {}) {
                     throw new Error(message);
                 tolerateErrors.errorMessages.push(message);
                 current = {};
+                currentItemStartPosition = undefined;
             }
             continue;
         }
         current[outputTag.key] = formatRawContent(rawTag.content, outputTag);
     }
+    // Handle the last item
     if (Object.keys(current).length > 0) {
-        const rawTag = ensureProperties(current, outputTags, options);
-        if (rawTag) {
-            result.push(rawTag);
+        const completedItem = tryCompleteItem(current, outputTags, titleOutputTag, llmResponse, previousItemEndPosition, currentItemStartPosition ?? 0, options);
+        if (completedItem) {
+            result.push(completedItem);
         }
     }
     return result;
 }
-function ensureProperties(obj, outputTags, options) {
+/**
+ * Try to complete an item by ensuring all required properties are present.
+ * If the title is missing, attempt to extract it from a Markdown heading
+ * in the gap before the item's first tag.
+ */
+function tryCompleteItem(obj, outputTags, titleOutputTag, llmResponse, gapStart, gapEnd, options) {
     const { tolerateErrors } = options;
+    // If title is missing and we have a title tag definition, try fallback extraction
+    if (titleOutputTag && !(titleOutputTag.key in obj)) {
+        const gapText = llmResponse.substring(gapStart, gapEnd);
+        const extractedTitle = extractMarkdownTitle(gapText);
+        if (extractedTitle) {
+            obj[titleOutputTag.key] = extractedTitle;
+        }
+    }
+    // Now check all required properties
     for (const tag of outputTags) {
         if (!(tag.key in obj) && !tag.optional) {
             const message = `Missing tag <${tag.tagName}>`;
@@ -86,6 +118,28 @@ function formatRawContent(rawContent, tag) {
             throw new Error(`Unknown format "${format}"`);
     }
 }
+/**
+ * Extract the first Markdown heading from a text snippet.
+ * Handles any heading depth (#, ##, ###, etc.) and strips bold markers (**).
+ * Returns undefined if no heading is found.
+ */
+export function extractMarkdownTitle(text) {
+    // Match any Markdown heading: # Title, ## Title, ### Page 1: **Title**, etc.
+    const headingMatch = text.match(/^#{1,6}\s+(.+)$/m);
+    if (!headingMatch)
+        return undefined;
+    let title = headingMatch[1].trim();
+    // Handle patterns like "Page 1: **Actual Title**" - extract just the title part
+    const colonMatch = title.match(/^(?:Page\s+\d+\s*:\s*)?(.+)$/i);
+    if (colonMatch) {
+        title = colonMatch[1].trim();
+    }
+    // Strip bold markers **title** -> title
+    title = title.replace(/^\*\*(.+)\*\*$/, "$1");
+    // Strip any trailing ** that might be left
+    title = title.replace(/\*\*/g, "").trim();
+    return title || undefined;
+}
 export function parseLlmRawTags(llmResponse, tagNames, options = {}) {
     const { tolerateErrors } = options;
     const tagList = [];
@@ -135,6 +189,7 @@ export function parseLlmRawTags(llmResponse, tagNames, options = {}) {
                     tagList.push({
                         tagName: current.tagName,
                         content,
+                        startPosition: current.position,
                     });
                     // Skip to after this closing tag
                     i = j;

package/backend/dist/generator/llm-queries/invoke-new-site-analysis.js

@@ -179,8 +179,22 @@ function assignFieldsToNodeTypes(ctx, assignedFields, nodeTypes) {
             ctx.logger.warn(`Missing assigned fields for node type "${typeName}"`);
             continue;
         }
+        // inject authors field in temporal documents
+        if (nodeType.kind === "document" &&
+            nodeType.documentKind === "regular" &&
+            nodeType.route === ":yyyy/:mm/:dd/:relativeId-:slug") {
+            nodeType.fields = [
+                {
+                    localized: false,
+                    storedAs: "labeling",
+                    name: "authors",
+                    taxonomy: "authors",
+                    multiple: true,
+                },
+            ];
+        }
         if (fieldNames.length > 0) {
-            nodeType.fields = fieldNames;
+            nodeType.fields = [...(nodeType.fields ?? []), ...fieldNames];
         }
         remainingTypeNames.delete(typeName);
     }

package/backend/dist/generator/site-generator/schema-with-authors.js

@@ -0,0 +1,69 @@
+// Default authors/author types (injected by site-schema-factory at runtime, but needed for template generation)
+const defaultAuthorsType = {
+    typeName: "authors",
+    kind: "document",
+    documentKind: "routing",
+    route: "authors",
+    regularChildren: ["author"],
+    regularChildrenSorting: "title asc",
+};
+const defaultAuthorType = {
+    typeName: "author",
+    kind: "document",
+    documentKind: "regular",
+    route: ":relativeId-:slug",
+    autoPublish: true,
+};
+/**
+ * Create a copy of the site schema with authors/author types injected if missing.
+ * This is needed because the site-schema-factory injects these at runtime,
+ * but we need them during template generation.
+ */
+export function createSchemaWithAuthors(siteSchema) {
+    const nodeTypes = siteSchema.nodeTypes ?? [];
+    const nodeTypeNames = new Set(nodeTypes.map((nt) => nt.typeName));
+    const hasAuthors = nodeTypeNames.has("authors");
+    const hasAuthor = nodeTypeNames.has("author");
+    // If both authors and author exist, check if home references authors
+    if (hasAuthors && hasAuthor) {
+        return ensureHomeReferencesAuthors(siteSchema);
+    }
+    const newNodeTypes = [...nodeTypes];
+    // Add author first (authors depends on it)
+    if (!hasAuthor) {
+        newNodeTypes.push(defaultAuthorType);
+    }
+    // Add authors
+    if (!hasAuthors) {
+        newNodeTypes.push(defaultAuthorsType);
+    }
+    return ensureHomeReferencesAuthors({
+        ...siteSchema,
+        nodeTypes: newNodeTypes,
+    });
+}
+/**
+ * Ensure the home document type has "authors" in its routingChildren.
+ */
+function ensureHomeReferencesAuthors(siteSchema) {
+    const nodeTypes = siteSchema.nodeTypes ?? [];
+    const homeIndex = nodeTypes.findIndex((nt) => nt.typeName === "home");
+    if (homeIndex === -1) {
+        return siteSchema;
+    }
+    const homeType = nodeTypes[homeIndex];
+    const routingChildren = homeType.routingChildren ?? [];
+    if (routingChildren.includes("authors")) {
+        return siteSchema;
+    }
+    // Create a new array with updated home type
+    const newNodeTypes = [...nodeTypes];
+    newNodeTypes[homeIndex] = {
+        ...homeType,
+        routingChildren: [...routingChildren, "authors"],
+    };
+    return {
+        ...siteSchema,
+        nodeTypes: newNodeTypes,
+    };
+}

package/backend/dist/generator/site-generator/site-generator.js

@@ -1,4 +1,5 @@
 import { generateSlug } from "@paroicms/public-anywhere-lib";
+import { createSimpleTranslator } from "@paroicms/public-server-lib";
 import { randomUUID } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -30,12 +31,13 @@ export async function generateSite(ctx, input) {
             "new-website",
     }), null, 2), "utf-8");
     await createTheme(ctx, siteDir, siteSchema);
-    const regSite = await service.connector.registerNewSite({
+    const regSite = await service.getServerConnector().registerNewSite({
         packName,
         siteDir,
         domain: siteId,
         version: "0.0.0",
     });
+    const siteConnector = service.getUnsafeSiteConnector({ fqdn: regSite.fqdn });
     const account = {
         kind: "local",
         email: `${siteId}@yopmail.com`,
@@ -43,7 +45,7 @@ export async function generateSite(ctx, input) {
         password: Math.random().toString(36).substring(2, 6), // 4 random lowercase characters,
         roles: ["admin"],
     };
-    await ctx.service.connector.createAccount(regSite.fqdn, account, { asContactEmail: true });
+    await siteConnector.createAccount(account, { asContactEmail: true });
     const { siteUrl } = regSite;
     const values = {
         status: withSampleData ? "pending" : "completed",
@@ -55,7 +57,20 @@ export async function generateSite(ctx, input) {
     };
     await saveGeneratedSiteStep(ctx, stepHandle, values);
     if (withSampleData) {
-        safeCallStep(ctx, stepHandle, () => fillSiteWithFakeContent(ctx, stepHandle, { regSite, localizedValues }));
+        const { siteSchema: loadedSiteSchema, homeRoutingCluster } = await siteConnector.loadSiteSchemaAndIds();
+        const schemaI18n = createSimpleTranslator({
+            labels: loadedSiteSchema.l10n,
+            logger: ctx.logger,
+        });
+        const generateCtx = {
+            ...ctx,
+            siteConnector,
+            fqdn: regSite.fqdn,
+            siteSchema: loadedSiteSchema,
+            schemaI18n,
+            homeRoutingCluster,
+        };
+        safeCallStep(ctx, stepHandle, () => fillSiteWithFakeContent(generateCtx, stepHandle, { homeRoutingCluster, localizedValues }));
     }
     return await loadStep(ctx, stepHandle.stepNumber);
 }

package/backend/dist/generator/site-generator/theme-creator.js

@@ -5,11 +5,13 @@ import { camelToKebabCase } from "../lib/utils.js";
 import { templateOfSiteFooter, templateOfSiteHeader } from "./common-template-creator.js";
 import { templateOfDocumentType } from "./document-template-creator.js";
 import { isMultilingual } from "./jt-site-schema-helpers.js";
+import { createSchemaWithAuthors } from "./schema-with-authors.js";
 import { createThemeCreatorContext } from "./theme-creator-context.js";
 import { getThemeCssContent } from "./theme-css.js";
 export async function createTheme(ctx, siteDir, siteSchema) {
-    const themeContext = createThemeCreatorContext(siteSchema);
-    for (const nodeType of siteSchema.nodeTypes ?? []) {
+    const schemaWithAuthors = createSchemaWithAuthors(siteSchema);
+    const themeContext = createThemeCreatorContext(schemaWithAuthors);
+    for (const nodeType of schemaWithAuthors.nodeTypes ?? []) {
         if (nodeType.kind === "site")
             continue;
         if (nodeType.kind === "part")

package/backend/dist/generator/site-schema-generator/create-site-schema.js

@@ -9,9 +9,10 @@ export function createSiteSchemaFromAnalysis(analysis) {
             "@paroicms/content-loading-plugin",
             "@paroicms/internal-link-plugin",
             "@paroicms/list-field-plugin",
+            "@paroicms/platform-video-plugin",
             "@paroicms/public-menu-plugin",
             "@paroicms/tiptap-editor-plugin",
-            "@paroicms/platform-video-plugin",
+            "@paroicms/zoom-plugin",
         ],
         nodeTypes: [
             {
@@ -249,7 +250,7 @@ function toRoutingDocumentNodeType(typeName, saType) {
     return documentType;
 }
 function toRegularDocumentNodeType(typeName, saType) {
-    return {
+    const docType = {
         typeName,
         kind: "document",
         documentKind: "regular",
@@ -257,4 +258,5 @@ function toRegularDocumentNodeType(typeName, saType) {
         route: saType.temporal ? ":yyyy/:mm/:dd/:relativeId-:slug" : ":relativeId-:slug",
         withFeaturedImage: true,
     };
+    return docType;
 }

package/backend/dist/lib/create-raw-context.js

@@ -4,7 +4,7 @@ import { readOrCreateJwtSecretSync } from "@paroicms/internal-server-lib";
 import { join } from "node:path";
 export function createRawContext(service, options) {
     const { cn, logNextQuery, pluginConf, debugDir } = options;
-    const packConf = service.connector.getSitePackConf(pluginConf.packName);
+    const packConf = service.getServerConnector().getSitePackConf(pluginConf.packName);
     const { sitesDir, packName } = packConf;
     if (!sitesDir || packConf.serveOn !== "subDomain") {
         throw new Error(`Site-generator plugin can generate sites only for sub-domain pack with "sitesDir", but pack "${packName}" doesn't have it`);

package/backend/dist/lib/site-remover.js

@@ -33,7 +33,9 @@ export async function removeExpiredSites(ctx) {
         const dirPath = join(sitesDir, entry.name);
         const st = await stat(dirPath);
         if (st.ctime < expirationTime) {
-            await service.connector.removeSite(`${entry.name}.${packConf.parentDomain}`);
+            const fqdn = `${entry.name}.${packConf.parentDomain}`;
+            const siteConnector = service.getUnsafeSiteConnector({ fqdn });
+            await siteConnector.removeSite();
         }
     }
 }

package/backend/prompts/generate-fake-content-multiple-terms.md

@@ -0,0 +1,21 @@
+Generate **{{count}}** different **taxonomy terms** (like categories or tags).
+
+All the produced texts must be in **{{language}}**.
+
+The taxonomy in question is: **{{typeLabel}}** ({{typeDescription}}).
+
+For the context, the website's theme is: "{{siteTheme}}".
+
+Make sure terms are distinct from each other.
+
+## IMPORTANT RULES
+
+1. You MUST use XML tags, NOT markdown headings
+2. Each term MUST have a `<title>` tag
+3. Do NOT use ### or ## or # for titles
+
+## REQUIRED FORMAT
+
+For each term, write EXACTLY like this:
+
+{{tagAndDescriptions}}