@paroicms/site-generator-plugin 0.7.0 → 0.8.1

package/gen-backend/ddl/site-generator.ddl.sql

@@ -0,0 +1,22 @@
+PRAGMA journal_mode = TRUNCATE;
+PRAGMA foreign_keys = 1;
+
+create table PaMetadata (
+  dbSchema varchar(100) not null,
+  k varchar(100) not null,
+  val varchar(250) not null,
+  primary key (dbSchema, k)
+);
+
+insert into PaMetadata (dbSchema, k, val) values ('site-generator', 'dbSchemaVersion', '1');
+
+create table PaGenSession (
+  id char(36) not null primary key,
+  createdAt timestamp not null default current_timestamp,
+  status varchar(100) not null,
+  guardCount integer not null default 0,
+  promptCount integer not null default 0,
+  nodeTypeCount integer not null default 0,
+  contentCount integer not null default 0,
+  errorMessage varchar(500)
+);

package/gen-backend/dist/commands/execute-command.js

@@ -0,0 +1,60 @@
+import { messageOf } from "@paroi/data-formatters-lib";
+import { updateSession } from "../db/db.queries.js";
+import { invokeMessageGuard } from "../generator/llm-queries/invoke-message-guard.js";
+import { invokeNewSiteAnalysis } from "../generator/llm-queries/invoke-new-site-analysis.js";
+import { invokeUpdateSiteSchema } from "../generator/llm-queries/invoke-update-site-schema.js";
+import { generateSite } from "../generator/site-generator/site-generator.js";
+import { newSession, verifySessionToken } from "./generator-session.js";
+export async function executeCommand(commandCtx, input) {
+    if (input.command === "newSession") {
+        return {
+            success: true,
+            result: await newSession(commandCtx, input),
+        };
+    }
+    const { sessionId } = await verifySessionToken(commandCtx, input.sessionToken);
+    const ctx = {
+        ...commandCtx,
+        sessionId,
+    };
+    try {
+        if (input.command === "createSiteSchema") {
+            const errorResponse = await invokeMessageGuard(ctx, input);
+            if (errorResponse)
+                return errorResponse;
+            return {
+                success: true,
+                result: await invokeNewSiteAnalysis(ctx, input),
+            };
+        }
+        if (input.command === "updateSiteSchema") {
+            const errorResponse = await invokeMessageGuard(ctx, input, { skipOutOfScopeCheck: true });
+            if (errorResponse)
+                return errorResponse;
+            return {
+                success: true,
+                result: await invokeUpdateSiteSchema(ctx, input),
+            };
+        }
+        if (input.command === "generateSite") {
+            return {
+                success: true,
+                result: await generateSite(ctx, input),
+            };
+        }
+        ctx.logger.error(`Invalid command: ${input.command}`);
+        return {
+            success: false,
+            userMessage: "Invalid command",
+        };
+    }
+    catch (error) {
+        try {
+            await updateSession(ctx, { status: "error", errorMessage: messageOf(error) });
+        }
+        catch {
+            ctx.logger.error("Failed to update session error message", error);
+        }
+        throw error;
+    }
+}

package/gen-backend/dist/{generator/session → commands}/generator-session.js

@@ -1,24 +1,25 @@
 import { ApiError } from "@paroicms/public-server-lib";
-import { nanoid } from "nanoid";
+import { randomUUID } from "node:crypto";
+import { insertSession, readSession } from "../db/db.queries.js";
 const { sign, verify } = (await import("jsonwebtoken")).default;
-const JWT_SECRET = "init"; // FIXME: Hardcoded JWT secret as specified
 export async function newSession(ctx, command) {
     const { service } = ctx;
     const { recaptchaToken } = command;
     const isValid = await service.validateRecaptchaResponse(recaptchaToken);
     if (!isValid)
         throw new ApiError("Invalid reCAPTCHA token", 400);
-    const sessionId = nanoid();
-    const token = sign({ sessionId }, JWT_SECRET, { expiresIn: "24h" });
+    const sessionId = randomUUID();
+    const token = sign({ sessionId }, ctx.jwtSecret, { expiresIn: "48h" });
+    await insertSession(ctx, { sessionId });
     return { token };
 }
 /**
  * Verifies a session token and returns the session ID if valid
  */
-export function verifySessionToken(token) {
+export async function verifySessionToken(ctx, token) {
     let payload;
     try {
-        payload = verify(token, JWT_SECRET);
+        payload = verify(token, ctx.jwtSecret);
     }
     catch (error) {
         if (error.name === "TokenExpiredError")
@@ -27,7 +28,14 @@ export function verifySessionToken(token) {
             throw new ApiError("Invalid session token", 401);
         throw error;
     }
-    if (!payload || !payload.sessionId)
+    if (!payload || !("sessionId" in payload) || typeof payload.sessionId !== "string") {
         throw new ApiError("Invalid session token", 401);
-    return payload.sessionId;
+    }
+    const sessionId = payload.sessionId;
+    const session = await readSession(ctx, sessionId);
+    if (!session)
+        throw new ApiError(`Missing session "${sessionId}"`, 500);
+    if (session.promptCount >= 20)
+        throw new ApiError("Session consumed", 401);
+    return { sessionId };
 }

package/gen-backend/dist/context.js

@@ -1,2 +1,8 @@
+import { strVal } from "@paroi/data-formatters-lib";
 import { resolveModuleDirectory } from "@paroicms/public-server-lib";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 export const projectDir = resolveModuleDirectory(import.meta.url, { parent: true });
+export const packageDir = dirname(projectDir);
+export const pluginVersion = strVal(JSON.parse(readFileSync(join(packageDir, "package.json"), "utf-8")).version);
+export const SLUG = "site-generator";

package/gen-backend/dist/db/db-init.js

@@ -0,0 +1,35 @@
+import { createOrOpenSqliteConnection, createSqlLogger, getMetadataDbSchemaVersion, } from "@paroicms/internal-server-lib";
+import { join } from "node:path";
+import { projectDir } from "../context.js";
+import { currentDbSchemaVersion, dbSchemaName, migrateSiteGeneratorDb } from "./ddl-migration.js";
+export async function createOrOpenSiteGeneratorConnection({ sqliteFile, canCreate, logger, }) {
+    const { logNextQuery, knexLogger } = createSqlLogger({ logger, dbSchemaName });
+    const { cn } = await createOrOpenSqliteConnection({
+        canCreate,
+        dbSchemaName,
+        sqliteFile,
+        ddlFile: join(projectDir, "ddl", "site-generator.ddl.sql"),
+        migrateDb,
+        knexLogger,
+        logger,
+    });
+    async function migrateDb(cn) {
+        const dbVersion = await getMetadataDbSchemaVersion(cn, { dbSchemaName });
+        if (dbVersion === currentDbSchemaVersion) {
+            return {
+                migrated: false,
+                schemaVersion: dbVersion,
+            };
+        }
+        await migrateSiteGeneratorDb(cn, {
+            fromVersion: dbVersion,
+            logger,
+        });
+        return {
+            migrated: true,
+            fromVersion: dbVersion,
+            schemaVersion: currentDbSchemaVersion,
+        };
+    }
+    return { cn, logNextQuery };
+}

package/gen-backend/dist/db/db.queries.js

@@ -0,0 +1,60 @@
+import { strVal, strValOrUndef } from "@paroi/data-formatters-lib";
+export async function readSession(ctx, sessionId) {
+    const { cn } = ctx;
+    const row = await cn("PaGenSession")
+        .select("id", "createdAt", "status", "guardCount", "promptCount", "nodeTypeCount", "contentCount", "errorMessage")
+        .where({ id: sessionId })
+        .first();
+    if (!row)
+        return;
+    return {
+        id: strVal(row.id),
+        createdAt: strVal(row.createdAt),
+        status: formatSessionStatus(row.status),
+        guardCount: Number(row.guardCount),
+        promptCount: Number(row.promptCount),
+        nodeTypeCount: Number(row.nodeTypeCount),
+        contentCount: Number(row.contentCount),
+        errorMessage: strValOrUndef(row.errorMessage),
+    };
+}
+export async function insertSession(ctx, { sessionId }) {
+    const { cn } = ctx;
+    await cn("PaGenSession").insert({
+        id: sessionId,
+        status: "started",
+    });
+}
+export async function updateSession(ctx, values) {
+    const { sessionId, cn } = ctx;
+    const { status, guardCountInc, promptCountInc, nodeTypeCount, contentCountInc, errorMessage } = values;
+    const affected = await cn("PaGenSession")
+        .where({
+        id: sessionId,
+    })
+        .update({
+        status,
+        guardCountInc: guardCountInc ? cn.raw(`guardCount + ${guardCountInc}`) : undefined,
+        promptCount: promptCountInc ? cn.raw(`promptCount + ${promptCountInc}`) : undefined,
+        nodeTypeCount,
+        contentCount: contentCountInc ? cn.raw(`contentCount + ${contentCountInc}`) : undefined,
+        errorMessage,
+    });
+    if (affected !== 1) {
+        throw new Error(`Session "${sessionId}" not found`);
+    }
+}
+function formatSessionStatus(val) {
+    const v = strVal(val);
+    if (v === "started")
+        return "started";
+    if (v === "analyzed")
+        return "analyzed";
+    if (v === "updated")
+        return "updated";
+    if (v === "generated")
+        return "generated";
+    if (v === "error")
+        return "error";
+    throw new Error(`Invalid session status: "${val}"`);
+}

package/gen-backend/dist/db/ddl-migration.js

@@ -0,0 +1,15 @@
+export const dbSchemaName = "site-generator";
+export const currentDbSchemaVersion = 1;
+export async function migrateSiteGeneratorDb(_cn, { fromVersion, logger }) {
+    const toVersion = currentDbSchemaVersion;
+    const currentVersion = fromVersion;
+    if (currentVersion === 1) {
+        // await cn.raw("...");
+        // await setMetadataDbSchemaVersion(cn, { dbSchemaName, value: 2 });
+        // currentVersion = 2;
+    }
+    if (currentVersion !== toVersion) {
+        throw new Error(`version of ${dbSchemaName} database should be '${toVersion}', but is '${currentVersion}'`);
+    }
+    logger.info(`${dbSchemaName} database was migrated from ${fromVersion} to ${currentVersion}`);
+}

package/gen-backend/dist/generator/fake-content-generator.ts/content-helpers.js

@@ -0,0 +1,17 @@
+export function dedupMessages(messages) {
+    const counters = new Map();
+    const result = [];
+    for (const m of messages) {
+        const counter = counters.get(m);
+        if (counter) {
+            counters.set(m, counter + 1);
+            continue;
+        }
+        counters.set(m, 1);
+        result.push(m);
+    }
+    return result.map((m) => {
+        const counter = counters.get(m);
+        return counter && counter > 1 ? `${m} (×${counter})` : m;
+    });
+}

package/gen-backend/dist/generator/fake-content-generator.ts/content-report.js

@@ -0,0 +1,11 @@
+export function createGeneratedContentReport() {
+    let contentCount = 0;
+    return {
+        getContentCount() {
+            return contentCount;
+        },
+        addContentCount(count) {
+            contentCount += count;
+        },
+    };
+}

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

@@ -2,19 +2,22 @@ import { getPartTypeByName, getRegularDocumentTypeByName, getRoutingDocumentType
 import { createSimpleTranslator, } from "@paroicms/public-server-lib";
 import { getRandomImagePath } from "../lib/images-lib.js";
 import { createTaskCollector } from "../lib/tasks.js";
+import { dedupMessages } from "./content-helpers.js";
+import { createGeneratedContentReport } from "./content-report.js";
 import { generateLocalizedFooterMention } from "./create-node-contents.js";
 import { generateFieldSetContent, generateMultipleFieldSetContents, } from "./generate-fake-content.js";
-export async function fillSiteWithFakeContent(ctx, { siteConf, siteId, siteTitle, }) {
+export async function fillSiteWithFakeContent(ctx, { regSite, siteTitle }) {
     const { service } = ctx;
-    const { fqdn } = siteConf;
+    const { fqdn } = regSite;
+    const report = createGeneratedContentReport();
     const { siteSchema, siteIds } = await service.connector.loadSiteSchemaAndIds(fqdn);
     const schemaI18n = createSimpleTranslator({
         labels: siteSchema.l10n,
         logger: ctx.logger,
     });
-    await updateSiteFields(ctx, { fqdn, siteSchema, siteId, siteTitle });
+    await updateSiteFields(ctx, report, { fqdn, siteSchema, siteTitle });
     const tasks = createTaskCollector(ctx);
-    fillRoutingDocumentAndAddChildren(ctx, tasks, {
+    fillRoutingDocumentAndAddChildren(ctx, tasks, report, {
         fqdn,
         siteSchema,
         schemaI18n,
@@ -28,15 +31,16 @@ export async function fillSiteWithFakeContent(ctx, { siteConf, siteId, siteTitle
         ctx.logger.warn(`Failed to generate ${errorMessages.length} documents:\n  - ${errorMessages.join("\n  - ")}`);
     }
     ctx.logger.debug(`… Executed ${doneCount} generating tasks`);
+    return report;
 }
-function fillRoutingDocumentAndAddChildren(ctx, tasks, siteOptions, nodeOptions) {
+function fillRoutingDocumentAndAddChildren(ctx, tasks, report, siteOptions, nodeOptions) {
     const { routingIds, nodeType } = nodeOptions;
     const { siteSchema } = siteOptions;
-    tasks.add(() => updateRoutingDocument(ctx, siteOptions, nodeOptions));
+    tasks.add(() => updateRoutingDocument(ctx, report, siteOptions, nodeOptions));
     for (const listType of nodeType.lists ?? []) {
         for (const typeName of listType.parts) {
             const partType = getPartTypeByName(siteSchema, typeName);
-            tasks.add(() => addParts(ctx, siteOptions, {
+            tasks.add(() => addParts(ctx, report, siteOptions, {
                 parentNodeId: routingIds.nodeId,
                 nodeType: partType,
                 documentType: nodeType,
@@ -48,24 +52,24 @@ function fillRoutingDocumentAndAddChildren(ctx, tasks, siteOptions, nodeOptions)
         const childIds = routingIds.children?.[typeName];
         if (!childIds)
             throw new Error(`Missing childIds for ${typeName}`);
-        fillRoutingDocumentAndAddChildren(ctx, tasks, siteOptions, {
+        fillRoutingDocumentAndAddChildren(ctx, tasks, report, siteOptions, {
             routingIds: childIds,
             nodeType: childType,
         });
     }
     for (const typeName of nodeType.regularChildren ?? []) {
         const childType = getRegularDocumentTypeByName(siteSchema, typeName);
-        tasks.add(() => addRegularDocuments(ctx, siteOptions, {
+        tasks.add(() => addRegularDocuments(ctx, report, siteOptions, {
             parentNodeId: routingIds.nodeId,
             nodeType: childType,
             documentType: childType,
         }));
     }
 }
-async function updateSiteFields(ctx, options) {
+async function updateSiteFields(ctx, _report, options) {
     const { service, logger } = ctx;
     logger.debug("Updating site fields…");
-    const { fqdn, siteSchema, siteId, siteTitle } = options;
+    const { fqdn, siteSchema, siteTitle } = options;
     const siteType = siteSchema.nodeTypes._site;
     const logoImageFile = getRandomImagePath();
     const fields = [
@@ -123,7 +127,7 @@ async function updateSiteFields(ctx, options) {
     await service.connector.updateSiteFields(fqdn, Object.fromEntries(fields));
     logger.debug("… Site fields updated");
 }
-async function updateRoutingDocument(ctx, siteOptions, nodeOptions) {
+async function updateRoutingDocument(ctx, report, siteOptions, nodeOptions) {
     ctx.logger.debug(`[TASK] Updating routing document "${nodeOptions.nodeType.typeName}"…`);
     const { routingIds, nodeType } = nodeOptions;
     const { fqdn, siteSchema, schemaI18n } = siteOptions;
@@ -139,8 +143,9 @@ async function updateRoutingDocument(ctx, siteOptions, nodeOptions) {
         nodeId: routingIds.nodeId,
         content: toRiDocumentContent(content, nodeType),
     });
+    report.addContentCount(1);
 }
-async function addRegularDocuments(ctx, siteOptions, nodeOptions) {
+async function addRegularDocuments(ctx, report, siteOptions, nodeOptions) {
     ctx.logger.debug(`[TASK] Adding regular documents "${nodeOptions.nodeType.typeName}"…`);
     const { parentNodeId, nodeType, documentType } = nodeOptions;
     const { fqdn, siteSchema, schemaI18n } = siteOptions;
@@ -157,15 +162,17 @@ async function addRegularDocuments(ctx, siteOptions, nodeOptions) {
         tolerateErrors,
         debugName: nodeType.kebabName,
     });
-    if (tolerateErrors.errorMessages.length > 0) {
-        ctx.logger.warn(`Error generating content for ${nodeType.typeName}:\n  - ${tolerateErrors.errorMessages.join("\n  - ")}`);
+    const errorMessages = dedupMessages(tolerateErrors.errorMessages);
+    if (errorMessages.length > 0) {
+        ctx.logger.warn(`Error generating content for ${nodeType.typeName}:\n  - ${errorMessages.join("\n  - ")}`);
     }
     await ctx.service.connector.addMultipleDocumentContents(fqdn, {
         parentNodeId,
         contents: list.map((content) => toRiDocumentContent(content, nodeType)),
     });
+    report.addContentCount(list.length);
 }
-async function addParts(ctx, siteOptions, nodeOptions) {
+async function addParts(ctx, report, siteOptions, nodeOptions) {
     ctx.logger.debug(`[TASK] Adding parts "${nodeOptions.nodeType.typeName}"…`);
     const { parentNodeId, nodeType, documentType } = nodeOptions;
     const { fqdn, siteSchema, schemaI18n } = siteOptions;
@@ -182,13 +189,15 @@ async function addParts(ctx, siteOptions, nodeOptions) {
         tolerateErrors,
         debugName: nodeType.kebabName,
     });
-    if (tolerateErrors.errorMessages.length > 0) {
-        ctx.logger.warn(`Error generating content for ${nodeType.typeName}:\n  - ${tolerateErrors.errorMessages.join("\n  - ")}`);
+    const errorMessages = dedupMessages(tolerateErrors.errorMessages);
+    if (errorMessages.length > 0) {
+        ctx.logger.warn(`Error generating content for ${nodeType.typeName}:\n  - ${errorMessages.join("\n  - ")}`);
     }
     await ctx.service.connector.addMultiplePartContents(fqdn, {
         parentNodeId,
         contents: list.map((content) => toRiPartContent(content, nodeType)),
     });
+    report.addContentCount(list.length);
 }
 function toRiDocumentContent(content, nodeType) {
     const { title, fields, featuredImage } = content;

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

@@ -106,9 +106,9 @@ export function parseLlmRawTags(llmResponse, tagNames, options = {}) {
         const current = matches[i];
         if (current.isOpening) {
             // Find the next corresponding closing tag
-            let j = i + 1;
+            const j = i + 1;
             let foundClosing = false;
-            while (j < matches.length) {
+            if (j < matches.length) {
                 const next = matches[j];
                 // If we encounter another opening tag of any type before finding our closing tag,
                 // it's an error if not tolerating errors
@@ -119,9 +119,15 @@ export function parseLlmRawTags(llmResponse, tagNames, options = {}) {
                     tolerateErrors.errorMessages.push(message);
                     foundClosing = undefined;
                     // If we are tolerating errors, we skip this opening tag entirely
-                    break;
                 }
-                if (!next.isOpening && next.tagName === current.tagName) {
+                else {
+                    if (next.tagName !== current.tagName) {
+                        // Found a non-matching closing tag
+                        const message = `Mismatched tags: opening <${current.tagName}>, closing </${next.tagName}>`;
+                        if (!tolerateErrors)
+                            throw new Error(message);
+                        tolerateErrors.errorMessages.push(message);
+                    }
                     // Found a matching closing tag
                     const contentStart = current.position + `<${current.tagName}>`.length;
                     const contentEnd = next.position;
@@ -133,19 +139,7 @@ export function parseLlmRawTags(llmResponse, tagNames, options = {}) {
                     // Skip to after this closing tag
                     i = j;
                     foundClosing = true;
-                    break;
                 }
-                if (!next.isOpening && next.tagName !== current.tagName) {
-                    // Found a non-matching closing tag
-                    const message = `Mismatched tags: opening <${current.tagName}>, closing </${next.tagName}>`;
-                    if (!tolerateErrors)
-                        throw new Error(message);
-                    tolerateErrors.errorMessages.push(message);
-                    foundClosing = undefined;
-                    // If we are tolerating errors, we skip this current opening tag entirely
-                    break;
-                }
-                ++j;
             }
             // Handle case where no matching closing tag was found
             if (foundClosing === false) {

package/gen-backend/dist/generator/llm-queries/invoke-message-guard.js

@@ -1,4 +1,5 @@
 import { boolVal, listValOrUndef, strVal, strValOrUndef, } from "@paroi/data-formatters-lib";
+import { updateSession } from "../../db/db.queries.js";
 import { createPromptTemplate } from "../lib/create-prompt.js";
 import { debugLlmOutput } from "../lib/debug-utils.js";
 import { parseLlmResponseAsProperties } from "../lib/parse-llm-response.js";
@@ -35,6 +36,7 @@ export async function invokeMessageGuard(ctx, input, { skipOutOfScopeCheck = fal
     }
     if (report.valid)
         return;
+    await updateSession(ctx, { guardCountInc: 1 });
     return {
         success: false,
         language: report.language,

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

@@ -1,3 +1,4 @@
+import { updateSession } from "../../db/db.queries.js";
 import { reorderObjectKeys } from "../helpers/js-utils.js";
 import { createPromptTemplate, getPredefinedFields, getSiteSchemaTsDefs, } from "../lib/create-prompt.js";
 import { debugLlmOutput } from "../lib/debug-utils.js";
@@ -17,13 +18,14 @@ const fieldsPrompt = await createPromptTemplate({
 export async function invokeNewSiteAnalysis(ctx, input) {
     const { analysis, explanation, unusedInformation } = await invokeAnalysisStep1(ctx, input);
     const siteSchema = createSiteSchemaFromAnalysis(analysis);
-    await invokeAnalysisStep2(ctx, { prompt: unusedInformation ?? "" }, siteSchema);
+    const { unusedInformation: unusedInformation2 } = await invokeAnalysisStep2(ctx, { prompt: createUnusedInformationPrompt(unusedInformation, analysis) ?? "" }, siteSchema);
     reorderSiteSchemaNodeTypes(siteSchema);
     const l10n = createL10n(analysis, siteSchema);
     const siteTitle = {
         [analysis.siteProperties.language]: analysis.siteProperties.title,
     };
-    if (!unusedInformation) {
+    if (!unusedInformation2) {
+        await updateSession(ctx, { status: "analyzed", promptCountInc: 1 });
         return {
             siteTitle,
             siteSchema,
@@ -32,15 +34,16 @@ export async function invokeNewSiteAnalysis(ctx, input) {
             explanation,
         };
     }
-    ctx.logger.debug("Unused information:", unusedInformation);
+    ctx.logger.debug("Unused information:", unusedInformation2);
     const updated = await invokeUpdateSiteSchema(ctx, {
-        prompt: unusedInformation,
+        prompt: unusedInformation2,
         generatedSchema: {
             siteTitle,
             siteSchema,
             l10n,
         },
-    });
+    }, { asRemainingPrompt: true });
+    await updateSession(ctx, { status: "analyzed", promptCountInc: 1 });
     return {
         siteTitle,
         siteSchema: updated.siteSchema,
@@ -122,16 +125,23 @@ siteSchema) {
         const llmMessage = await fieldsPrompt.pipe(ctx.goodModel).invoke(llmInput);
         llmMessageContent = await debug.getMessageContent(llmMessage);
     }
-    const { assignedFields } = parseLlmResponseAsProperties(llmMessageContent, [
+    const { assignedFields, unusedInformation } = parseLlmResponseAsProperties(llmMessageContent, [
         {
             tagName: "yaml_result",
             key: "assignedFields",
             format: "yaml",
         },
+        {
+            tagName: "unused_information_md",
+            key: "unusedInformation",
+            format: "markdown",
+            optional: true,
+        },
     ]);
     if (siteSchema.nodeTypes) {
         assignFieldsToNodeTypes(ctx, assignedFields, siteSchema.nodeTypes);
     }
+    return { unusedInformation };
 }
 function assignFieldsToNodeTypes(ctx, assignedFields, nodeTypes) {
     const remainingTypeNames = new Set(Object.keys(assignedFields));
@@ -169,3 +179,15 @@ function reorderSiteSchemaNodeTypes(siteSchema) {
         "orderChildrenBy",
     ]));
 }
+function createUnusedInformationPrompt(unusedInformation, analysis) {
+    const prompts = Object.entries(analysis.dictionary)
+        .map(([typeName, entry]) => {
+        return entry.prompt ? `${typeName}: ${entry.prompt}` : undefined;
+    })
+        .filter(Boolean);
+    if (prompts.length > 0) {
+        const nodeTypePrompts = `To do:\n\n- ${prompts.join("- \n")}`;
+        return unusedInformation ? `${nodeTypePrompts}\n\n${unusedInformation}` : nodeTypePrompts;
+    }
+    return unusedInformation;
+}

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

@@ -1,3 +1,4 @@
+import { updateSession } from "../../db/db.queries.js";
 import { createPromptTemplate, getPredefinedFields, getSiteSchemaTsDefs, } from "../lib/create-prompt.js";
 import { debugLlmOutput } from "../lib/debug-utils.js";
 import { parseLlmResponseAsProperties } from "../lib/parse-llm-response.js";
@@ -7,7 +8,7 @@ const prompt1Tpl = await createPromptTemplate({
 const prompt2Tpl = await createPromptTemplate({
     fileName: "update-site-schema-2-execute.md",
 });
-export async function invokeUpdateSiteSchema(ctx, input) {
+export async function invokeUpdateSiteSchema(ctx, input, { asRemainingPrompt = false } = {}) {
     const task = await invokeUpdateSiteSchemaStep1(ctx, input);
     if (!task.taskDetailsMd) {
         // no changes
@@ -21,6 +22,9 @@ export async function invokeUpdateSiteSchema(ctx, input) {
         taskDetailsMd: task.taskDetailsMd,
         generatedSchema: input.generatedSchema,
     });
+    if (!asRemainingPrompt) {
+        await updateSession(ctx, { status: "updated", promptCountInc: 1 });
+    }
     return {
         ...genSchema,
         changed: true,

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

@@ -1,17 +1,13 @@
 import { generateSlug } from "@paroicms/public-anywhere-lib";
-import { randomUUID } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { updateSession } from "../../db/db.queries.js";
 import { fillSiteWithFakeContent } from "../fake-content-generator.ts/create-database-with-fake-content.js";
 import { createTheme } from "./theme-creator.js";
 export async function generateSite(ctx, input) {
-    const { service, logger, packConf } = ctx;
-    const { sitesDir, packName } = packConf;
+    const { service, logger, sitesDir, packConf: { packName }, } = ctx;
     const { generatedSchema: { l10n, siteSchema, siteTitle }, withFakeContent, } = input;
-    if (!sitesDir) {
-        throw new Error(`Site-generator plugin can generate sites only for pack with "sitesDir", but pack "${packName}" doesn't have it`);
-    }
-    const siteId = randomUUID();
+    const siteId = ctx.sessionId;
     logger.info(`Generating site: ${siteId}…`);
     const siteDir = join(sitesDir, siteId);
     await mkdir(siteDir);
@@ -23,14 +19,17 @@ export async function generateSite(ctx, input) {
         siteTitle: siteTitle.en ?? Object.values(siteTitle)[0] ?? "new-website",
     }), null, 2), "utf-8");
     await createTheme(ctx, siteDir, siteSchema);
-    const siteConf = await service.registerNewSite({
+    const regSite = await service.connector.registerNewSite({
         packName,
         siteDir,
         domain: siteId,
         version: "0.0.0",
     });
     if (withFakeContent) {
-        await fillSiteWithFakeContent(ctx, { siteConf, siteId, siteTitle });
+        const report = await fillSiteWithFakeContent(ctx, { regSite, siteTitle });
+        await updateSession(ctx, {
+            contentCountInc: report.getContentCount(),
+        });
     }
     const account = {
         kind: "local",
@@ -38,8 +37,12 @@ export async function generateSite(ctx, input) {
         name: "Admin",
         password: Math.random().toString(36).substring(2, 6), // 4 random lowercase characters,
     };
-    await ctx.service.connector.createAccount(siteConf.fqdn, account, { asContactEmail: true });
-    const { siteUrl } = siteConf;
+    await ctx.service.connector.createAccount(regSite.fqdn, account, { asContactEmail: true });
+    const { siteUrl } = regSite;
+    await updateSession(ctx, {
+        status: "generated",
+        nodeTypeCount: siteSchema.nodeTypes?.length ?? 0,
+    });
     return {
         siteId,
         url: siteUrl,

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

@@ -9,6 +9,7 @@ export function createSiteSchemaFromAnalysis(analysis) {
             "@paroicms/content-loading-plugin",
             "@paroicms/public-menu-plugin",
             "@paroicms/contact-form-plugin",
+            "@paroicms/video-plugin",
         ],
         nodeTypes: [
             {