@paroicms/site-generator-plugin 1.0.1 → 1.2.0

package/backend/dist/generator/fake-content-generator/create-database-with-fake-content.js

@@ -1,4 +1,4 @@
-import { getPartTypeByName, getRegularDocumentTypeByName, getRoutingDocumentTypeByName, } from "@paroicms/internal-anywhere-lib";
+import { getPartTypeByName, getRegularDocumentTypeByName, getRoutingDocumentTypeByName, isRootOfSubRoutingCluster, } from "@paroicms/internal-anywhere-lib";
 import { updateGeneratedSiteStepSetAsCompleted, } from "../../db/db-write.queries.js";
 import { createTaskCollector } from "../lib/tasks.js";
 import { createGeneratedContentReport } from "./content-report.js";
@@ -58,10 +58,40 @@ function fillRoutingDocumentAndAddChildren(ctx, tasks, report, nodeOptions) {
     }
     for (const typeName of nodeType.regularChildren ?? []) {
         const childType = getRegularDocumentTypeByName(siteSchema, typeName);
-        tasks.add(() => addRegularDocuments(ctx, report, {
-            parentNodeId: clusterNode.nodeId,
-            nodeType: childType,
-            documentType: childType,
-        }));
+        if (isRootOfSubRoutingCluster(childType)) {
+            // Each created instance is the root of its own sub routing cluster (auto-created
+            // synchronously by `createDocument`). Load each sub-cluster and recurse to fill it.
+            tasks.add(async () => {
+                const created = await addRegularDocuments(ctx, report, {
+                    parentNodeId: clusterNode.nodeId,
+                    nodeType: childType,
+                    documentType: childType,
+                });
+                for (const doc of created) {
+                    const subCluster = await ctx.siteConnector.loadRoutingClusterFromNode({
+                        nodeId: doc.nodeId,
+                        typeName: childType.typeName,
+                    });
+                    for (const routingTypeName of childType.routingChildren ?? []) {
+                        const childNode = subCluster.children?.[routingTypeName];
+                        if (!childNode)
+                            continue;
+                        fillRoutingDocumentAndAddChildren(ctx, tasks, report, {
+                            clusterNode: childNode,
+                            nodeType: getRoutingDocumentTypeByName(siteSchema, routingTypeName),
+                        });
+                    }
+                }
+            });
+        }
+        else {
+            tasks.add(async () => {
+                await addRegularDocuments(ctx, report, {
+                    parentNodeId: clusterNode.nodeId,
+                    nodeType: childType,
+                    documentType: childType,
+                });
+            });
+        }
     }
 }

package/backend/dist/generator/fake-content-generator/fill-lnodes.js

@@ -1,5 +1,5 @@
 import { encodeLNodeId, } from "@paroicms/public-anywhere-lib";
-import { getHandleOfFeaturedImage, getHandleOfFieldOnNode } from "@paroicms/public-server-lib";
+import { getHandleOfFeaturedImage, getHandleOfFieldOnNode, } from "@paroicms/public-server-lib";
 import { dedupMessages, getTermTypeNames } from "./content-helpers.js";
 import { generateFieldSetContent, generateMultipleFieldSetContents, } from "./generate-fake-content.js";
 export async function updateRoutingDocument(ctx, report, nodeOptions) {
@@ -42,7 +42,7 @@ export async function addRegularDocuments(ctx, report, nodeOptions) {
     // Special case: author terms are created without LLM
     if (nodeOptions.nodeType.typeName === "author") {
         await addSingleAuthor(ctx, report, nodeOptions);
-        return;
+        return [];
     }
     ctx.logger.debug(`[TASK] Adding regular documents "${nodeOptions.nodeType.typeName}"…`);
     const { parentNodeId, nodeType, documentType } = nodeOptions;
@@ -76,6 +76,7 @@ export async function addRegularDocuments(ctx, report, nodeOptions) {
     if (errorMessages.length > 0) {
         ctx.logger.warn(`Error generating content for ${nodeType.typeName}:\n  - ${errorMessages.join("\n  - ")}`);
     }
+    const createdInfos = [];
     for (const content of list) {
         const [firstLanguage, ...otherLanguages] = siteSchema.languages;
         const parentLNodeId = encodeLNodeId({ nodeId: parentNodeId, language: firstLanguage });
@@ -87,6 +88,7 @@ export async function addRegularDocuments(ctx, report, nodeOptions) {
             values: content.fields,
         });
         const nodeId = info.nodeId;
+        createdInfos.push(info);
         await uploadMediaEntries(ctx, nodeId, content.medias);
         report.addId({
             typeName: nodeType.typeName,
@@ -109,6 +111,7 @@ export async function addRegularDocuments(ctx, report, nodeOptions) {
             });
         }
     }
+    return createdInfos;
 }
 const HERO_NAMES = [
     "Mario",

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

@@ -56,7 +56,7 @@ export async function invokeGenerateFakeContent(ctx, input, outputTags, options)
             llmTaskName,
             temperature: 0.1,
             maxTokens: 50_000,
-            timeoutMs: 60_000,
+            timeoutMs: 120_000,
         });
         llmOutput = await debug.getMessageContents(results);
     }

package/backend/dist/generator/lib/markdown-bulleted-list-parser.js

@@ -68,9 +68,6 @@ function appendChildToParentNode(child, parent) {
         parent.children.push(child);
     }
     else if (parent.kind === "regularDocument") {
-        if (child.kind === "routingDocument") {
-            throw new Error(`Regular document type "${parent.typeName}" cannot have ${child.kind} child "${child.typeName}"`);
-        }
         parent.children ??= [];
         parent.children.push(child);
     }
@@ -131,7 +128,8 @@ export function parseLine(input, index) {
         };
     }
     // list of `pageSection` (parts), list name: `partSections`
-    const partMatch = cleanLine.match(/^list of `([^`]+)` \(parts\),? list name: `([^`]+)`$/);
+    // The list name backticks are optional: the LLM is inconsistent about wrapping it.
+    const partMatch = cleanLine.match(/^list of `([^`]+)` \(parts\),? list name: `?([^`]+?)`?$/);
     if (partMatch) {
         return {
             kind: "part",

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

@@ -9,7 +9,7 @@ import { parseMarkdownBulletedList } from "../lib/markdown-bulleted-list-parser.
 import { parseLlmResponseAsProperties } from "../lib/parse-llm-response.js";
 import { safeCallStep } from "../lib/session-utils.js";
 import { createL10n } from "../site-schema-generator/create-l10n.js";
-import { createSiteSchemaFromAnalysis } from "../site-schema-generator/create-site-schema.js";
+import { createSiteSchemaFromAnalysis, ensureSubClusterAutoCreate, } from "../site-schema-generator/create-site-schema.js";
 import { invokeUpdateSiteSchema } from "./invoke-update-site-schema.js";
 export const analyzePrompt = await createPromptTemplate({
     filename: "initial-1-analysis.md",
@@ -37,6 +37,7 @@ export async function invokeInitialAnalysis(ctx, stepHandle, input) {
     });
     const { unusedInformation: unusedInformation2, llmReport: llmReport2 } = await invokeAnalysisStep2(ctx, { prompt: createUnusedInformationPrompt(unusedInformation, analysis) ?? "" }, siteSchema, stepHandle);
     reorderSiteSchemaNodeTypes(siteSchema);
+    ensureSubClusterAutoCreate(siteSchema);
     const l10n = createL10n(analysis, siteSchema);
     const siteTitle = {
         [analysis.siteProperties.language]: analysis.siteProperties.title,
@@ -79,7 +80,7 @@ async function invokeAnalysisStep1(ctx, input, stepHandle) {
         const { messageContent, report } = await invokeClaude(ctx, {
             llmTaskName,
             prompt,
-            maxTokens: 4_000,
+            maxTokens: 10_000,
             temperature: 0.1,
             systemInstruction: "beSmart",
         });
@@ -146,7 +147,7 @@ siteSchema, stepHandle) {
         const { messageContent, report } = await invokeClaude(ctx, {
             llmTaskName,
             prompt,
-            maxTokens: 700,
+            maxTokens: 1_000,
             temperature: 0.1,
             systemInstruction: "beFast",
         });

package/backend/dist/generator/llm-queries/invoke-update-site-schema.js

@@ -5,6 +5,7 @@ import { createPromptTemplate, getPredefinedFields, getSiteSchemaTsDefs, } from
 import { debugLlmOutput } from "../lib/debug-utils.js";
 import { parseLlmResponseAsProperties } from "../lib/parse-llm-response.js";
 import { safeCallStep } from "../lib/session-utils.js";
+import { ensureSubClusterAutoCreate } from "../site-schema-generator/create-site-schema.js";
 const prompt1Tpl = await createPromptTemplate({
     filename: "update-site-schema-1-write-details.md",
 });
@@ -56,6 +57,7 @@ export async function invokeUpdateSiteSchema(ctx, stepHandle, input, { asRemaini
                 : asRemainingOf.explanation;
         }
     }
+    ensureSubClusterAutoCreate(completedValues.siteSchema);
     await saveCompletedSchemaStep(ctx, stepHandle, completedValues);
 }
 async function invokeUpdateSiteSchemaStep1(ctx, input, stepHandle) {
@@ -80,7 +82,7 @@ async function invokeUpdateSiteSchemaStep1(ctx, input, stepHandle) {
         const { messageContent, report } = await invokeClaude(ctx, {
             llmTaskName,
             prompt: message,
-            maxTokens: 1_500,
+            maxTokens: 3_000,
             temperature: 0.1,
             systemInstruction: "beSmart",
         });
@@ -126,7 +128,7 @@ async function invokeUpdateSiteSchemaStep2(ctx, input, stepHandle) {
         const { messageContent, report } = await invokeClaude(ctx, {
             llmTaskName,
             prompt: message,
-            maxTokens: 7_000,
+            maxTokens: 15_000,
             temperature: 0.1,
             systemInstruction: "beSmart",
         });

package/backend/dist/generator/site-generator/labeled-list-template-creator.js

@@ -46,11 +46,27 @@ function getRoutingKeyInCluster(ctx, documentType, options) {
                 return found;
         }
     }
-    const clusterRootTypeName = "home"; // limitation here: only works for the "home" cluster
+    // Resolve the cluster root of the taxonomy by walking ancestors via the parent map: the nearest
+    // ancestor that is "home" or a regular document carrying routing children.
+    function findClusterRoot(startTypeName) {
+        let current = getNodeType(startTypeName);
+        while (current && current.kind === "document") {
+            if (current.typeName === "home")
+                return "home";
+            if (current.documentKind === "regular" && (current.routingChildren?.length ?? 0) > 0) {
+                return current.typeName;
+            }
+            current = ctx.getParentTypes(current)[0];
+        }
+        return undefined;
+    }
+    const clusterRootTypeName = findClusterRoot(options.sameClusterAs.typeName);
+    if (!clusterRootTypeName)
+        return;
     const targetPath = findPath(documentType.typeName, clusterRootTypeName, []);
     const sameClusterPath = findPath(options.sameClusterAs.typeName, clusterRootTypeName, []);
     if (!targetPath || !sameClusterPath)
         return;
-    targetPath.shift(); // remove leading 'home'
+    targetPath.shift(); // remove the leading cluster root (path is cluster-root-relative at runtime)
     return `doc.cluster.routing.${targetPath.join(".")}`;
 }

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

@@ -48,11 +48,12 @@ export async function generateSite(ctx, input) {
         version: "0.0.0",
     });
     const siteConnector = service.getUnsafeSiteConnector({ fqdn: regSite.fqdn });
+    const password = Math.random().toString(36).substring(2, 6); // 4 random lowercase characters
     const account = {
         kind: "local",
         email: `${siteId}@yopmail.com`,
         name: "Admin",
-        password: Math.random().toString(36).substring(2, 6), // 4 random lowercase characters,
+        password,
         roles: ["admin"],
     };
     await siteConnector.createAccount(account, { asContactEmail: true });
@@ -63,7 +64,7 @@ export async function generateSite(ctx, input) {
         siteUrl,
         localizedValues,
         loginEmail: account.email,
-        loginPassword: account.password,
+        loginPassword: password,
     };
     await saveGeneratedSiteStep(ctx, stepHandle, values);
     if (withSampleData) {
@@ -91,7 +92,7 @@ function getPackageJsonContent(options) {
         private: true,
         type: "module",
         scripts: {
-            start: "paroicms | npm run _pino-pretty",
+            start: "paroicms-server | npm run _pino-pretty",
             "start:dev": "nodemon --watch './site-schema*.json' --watch ./config.json",
             clear: "rimraf theme/assets/bundle.css",
             build: "postcss theme/assets/css/index.css -o theme/assets/bundle.css",
@@ -104,7 +105,7 @@ function getPackageJsonContent(options) {
             "@paroicms/content-loading-plugin": "*",
             "@paroicms/internal-link-plugin": "*",
             "@paroicms/list-field-plugin": "*",
-            "@paroicms/mcp-plugin": "*",
+            "@paroicms/api-plugin": "*",
             "@paroicms/public-menu-plugin": "*",
             "@paroicms/tiptap-editor-plugin": "*",
             "@paroicms/platform-video-plugin": "*",

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

@@ -67,12 +67,12 @@ function makeGetParentTypes(siteSchema) {
     for (const type of nodeTypes) {
         if (type.kind !== "document")
             continue;
-        if (type.documentKind === "routing") {
-            for (const childName of type.routingChildren ?? []) {
-                const list = parentsByChild.get(childName) ?? [];
-                list.push(type);
-                parentsByChild.set(childName, list);
-            }
+        // Register routing-child → parent links for every document kind, so a routing document nested
+        // under a regular parent (sub routing cluster root) keeps its parent link.
+        for (const childName of type.routingChildren ?? []) {
+            const list = parentsByChild.get(childName) ?? [];
+            list.push(type);
+            parentsByChild.set(childName, list);
         }
         for (const childName of type.regularChildren ?? []) {
             const list = parentsByChild.get(childName) ?? [];

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

@@ -9,7 +9,7 @@ export function createSiteSchemaFromAnalysis(analysis) {
             "@paroicms/content-loading-plugin",
             "@paroicms/internal-link-plugin",
             "@paroicms/list-field-plugin",
-            "@paroicms/mcp-plugin",
+            "@paroicms/api-plugin",
             "@paroicms/platform-video-plugin",
             "@paroicms/public-menu-plugin",
             "@paroicms/tiptap-editor-plugin",
@@ -24,6 +24,20 @@ export function createSiteSchemaFromAnalysis(analysis) {
     };
     return siteSchema;
 }
+/**
+ * Ensures every regular document that is the root of a sub routing cluster (i.e. has routing
+ * children) carries `cluster: { autoCreate: true }`. The LLM schema-update step sometimes strips
+ * this flag; without it the runtime would not auto-create the sub-cluster nodes.
+ */
+export function ensureSubClusterAutoCreate(siteSchema) {
+    for (const nodeType of siteSchema.nodeTypes ?? []) {
+        if (nodeType.kind !== "document" || nodeType.documentKind !== "regular")
+            continue;
+        if ((nodeType.routingChildren?.length ?? 0) === 0)
+            continue;
+        nodeType.cluster ??= { autoCreate: true };
+    }
+}
 function toNodeTypes(analysis) {
     const nodeTypes = new Map(Object.entries(analysis.dictionary)
         .map(([typeName, saType]) => [typeName, toNodeType(typeName, saType)])
@@ -69,7 +83,6 @@ function walkTree(saNode, parentNode, ctx) {
                     nodeType,
                     typeName,
                     parentNode,
-                    children: undefined,
                 }, ctx);
             }
             else {
@@ -84,7 +97,6 @@ function walkTree(saNode, parentNode, ctx) {
                 nodeType,
                 typeName,
                 parentNode,
-                children: undefined,
                 listName: saNode.listName,
             }, ctx);
         }
@@ -117,7 +129,6 @@ function walkTree(saNode, parentNode, ctx) {
                 nodeType,
                 typeName,
                 parentNode,
-                children: saNode.children,
             }, ctx);
         }
         else if (saNode.kind === "part") {
@@ -130,7 +141,6 @@ function walkTree(saNode, parentNode, ctx) {
                 nodeType,
                 typeName,
                 parentNode,
-                children: saNode.children,
                 listName: saNode.listName,
             }, ctx);
         }
@@ -153,14 +163,15 @@ function appendAsRoutingChild(options) {
     if (parentNode.kind !== "document") {
         throw new Error(`In the tree, "${typeName}" is used as a routing document but its parent is a "${parentNode.kind}"`);
     }
-    if (parentNode.documentKind !== "routing") {
-        throw new Error(`Due to a technical limitation, routing document "${typeName}" can't be used as child of "${parentNode.documentKind}"`);
-    }
+    // A regular document with routing children is the root of a sub routing cluster: flag it so the
+    // runtime auto-creates the sub-cluster nodes (consistent with how the "home" cluster behaves).
+    if (parentNode.documentKind === "regular")
+        parentNode.cluster ??= { autoCreate: true };
     parentNode.routingChildren ??= [];
     parentNode.routingChildren.push(typeName);
 }
 function appendAsChildRegularDocument(options, ctx) {
-    const { nodeType, typeName, parentNode, children } = options;
+    const { nodeType, typeName, parentNode } = options;
     const saType = ctx.analysis.dictionary[typeName];
     if (nodeType.kind !== "document") {
         throw new Error(`In the tree, "${typeName}" is used as a regular document but it is a "${nodeType.kind}"`);
@@ -176,12 +187,9 @@ function appendAsChildRegularDocument(options, ctx) {
         parentNode.regularChildrenSorting = saType.temporal ? "publishDate desc" : "title asc";
     }
     parentNode.regularChildren.push(typeName);
-    for (const child of children ?? []) {
-        walkTree(child, nodeType, ctx);
-    }
 }
 function appendAsChildPart(options, ctx) {
-    const { nodeType, typeName, parentNode, children, listName } = options;
+    const { nodeType, typeName, parentNode, listName } = options;
     const saType = ctx.analysis.dictionary[typeName];
     if (nodeType.kind !== "part") {
         throw new Error(`In the tree, "${typeName}" is used as a part but it is a "${nodeType.kind}"`);
@@ -208,9 +216,6 @@ function appendAsChildPart(options, ctx) {
     else {
         throw new Error(`Unexpected kind: "${parentNode.kind}"`);
     }
-    for (const child of children ?? []) {
-        walkTree(child, nodeType, ctx);
-    }
 }
 function toNodeType(typeName, saType) {
     if (saType.kind === "part")

package/backend/prompts/initial-1-analysis.md

@@ -53,7 +53,7 @@ Guidelines for creating the hierarchical bullet list:
   - Start with a **bullet** (*).
   - Write `"list of"`, and then the **type name** within backquotes.
   - Append `(parts)`.
-  - Add a coma, then write: `"list name:"` and append an identifier for the list name.
+  - Add a coma, then write: `"list name:"` and append an identifier for the list name, **within backquotes**.
 - Avoid recursivity. But if you can't avoid reusing a node type, then write its children only on the first occurence.
 - On this task, do not focus on fields. If the website description provide fields then you will report them in the unused information. In particular, a collection of medias (a carousel, a slider, an image gallery, a slideshow, etc.) is a type of field.
 - Don't try to provide a comment mechanism when the user requests a blog. Blog comments do not belong to the hierarchy of node types.
@@ -115,6 +115,8 @@ Here's an example of correct output using parts, and with the default contact an
   - `searchPage` (routing document)
 </correct_example>
 
+A routing document **can** be a child of a regular document. This is a valid and supported structure: each instance of the regular document becomes the root of its own nested set of sections (a _sub routing cluster_). Keep such nesting when the website description implies it.
+
 ### Keep it simple
 
 When you have a choice, keep it simple. If the user lets you invent the site's structure, limit the site's sections to **2 main entries**. For example, a “news” routing document with a list of articles and categories, and a list of pages on the site's theme. Plus the usual contact and search pages.

package/backend/prompts/update-site-schema-1-write-details.md

@@ -50,6 +50,7 @@ Guidelines for reformulating into a detailed sequence of operations:
 - If the user's request is simple and doesn't need to be separated into several operations, write a list with a single operation.
 - Describe each operation concisely in a few words.
 - Make sure that the tree structure of node types is not broken. The `site` node is separate. Then, the root of the tree structure is the `home` routing document. Every other routing document type, regular document type, part type, must be the child of another node type.
+- A routing document type **can** be a child of a regular document type: this is a valid _sub routing cluster_ (each instance of the regular document is the root of its own nested sections). Preserve such nesting. A regular document type that has `routingChildren` can carry `cluster: { autoCreate: true }`.
 - Prefer predefined fields where you can. In particular, you can use the `"gallery"` field when the user description is a synonym (carousel, slider, slideshow, image gallery).
 - Never use the same field twice in a list of fields.
 

package/backend/prompts/update-site-schema-2-execute.md

@@ -129,6 +129,7 @@ Also, the attached locales:
 - You are allowed to be proactive, but only when the user asks you to do something.
 - Remember to adhere strictly to the TypeScript typing when making changes. If the update message requests changes that would violate the typing, then prioritize maintaining the correct structure over making those specific changes.
 - Field choice for listing pages: For new routing documents that have `regularChildren` (like blog index, products index, etc.), prefer `introduction[@paroicms/tiptap-editor-plugin]` instead of `htmlContent[@paroicms/tiptap-editor-plugin]`. These pages display a list of child items, so they only need a short introduction, not full HTML content.
+- Preserve _sub routing clusters_: a regular document type may have a routing document type among its `routingChildren`. Keep that nesting intact. A regular document type that has `routingChildren` can carry `cluster: { autoCreate: true }`.
 
 # 8. Output