@paroicms/site-generator-plugin 0.1.0

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

@@ -0,0 +1,86 @@
+import { boolVal, listValOrUndef, strVal, strValOrUndef, } from "@paroi/data-formatters-lib";
+import { createPromptTemplate } from "../lib/create-prompt.js";
+import { debugLlmOutput } from "../lib/debug-utils.js";
+import { parseLlmResponseAsProperties } from "../lib/parse-llm-response.js";
+const guardPrompt = await createPromptTemplate({
+    fileName: "message-guard.md",
+});
+const invalidCauses = new Set(["rude", "malicious", "outOfScope", "technicalLimits", "noSense"]);
+export async function invokeMessageGuard(ctx, input) {
+    const debugName = "guard";
+    const llmInput = {
+        message: input.prompt,
+    };
+    const debug = await debugLlmOutput(ctx, debugName, ctx.goodModelName, {
+        message: llmInput.message,
+    });
+    let llmMessageContent = debug.storedContent;
+    if (!llmMessageContent) {
+        const llmMessage = await guardPrompt.pipe(ctx.goodModel).invoke(llmInput);
+        llmMessageContent = await debug.getMessageContent(llmMessage);
+    }
+    const rawReport = parseLlmResponseAsProperties(llmMessageContent, [
+        {
+            tagName: "guard_yaml",
+            key: "guard",
+            format: "yaml",
+        },
+    ]);
+    const report = formatMessageGuardReport(rawReport.guard);
+    if (report.valid)
+        return;
+    return {
+        success: false,
+        language: report.language,
+        userMessage: report.explanation ?? toUserMessage(report.causes, report.language),
+    };
+}
+function toUserMessage(causes, language) {
+    if (!causes || causes.length === 0)
+        return "Invalid message";
+    return causes.map((cause) => getCauseLabel(cause, language)).join(", ");
+}
+function getCauseLabel(cause, language) {
+    if (language === "fr") {
+        switch (cause) {
+            case "rude":
+            case "malicious":
+                return "Nous ne pouvons pas répondre à cette demande";
+            case "outOfScope":
+                return "Hors sujet";
+            case "technicalLimits":
+                return "Limites techniques";
+            case "noSense":
+                return "Nous ne comprenons pas la demande";
+            default:
+                return cause;
+        }
+    }
+    switch (cause) {
+        case "rude":
+        case "malicious":
+            return "We cannot answer to this request";
+        case "outOfScope":
+            return "Out of scope";
+        case "technicalLimits":
+            return "Technical limits";
+        case "noSense":
+            return "We do not understand the request";
+        default:
+            return cause;
+    }
+}
+function formatMessageGuardReport(rawReport) {
+    return {
+        language: strValOrUndef(rawReport.language, { varName: "language" }),
+        valid: boolVal(rawReport.valid, { varName: "valid" }),
+        causes: listValOrUndef(rawReport.causes, formatGuardInvalidCause),
+        explanation: strValOrUndef(rawReport.explanation, { varName: "explanation" }),
+    };
+}
+function formatGuardInvalidCause(cause) {
+    const v = strVal(cause, { varName: "cause" });
+    if (!invalidCauses.has(v))
+        throw new Error(`Invalid cause: "${v}"`);
+    return v;
+}

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

@@ -0,0 +1,169 @@
+import { reorderObjectKeys } from "../helpers/js-utils.js";
+import { createPromptTemplate, getPredefinedFields, getSiteSchemaTsDefs, } from "../lib/create-prompt.js";
+import { debugLlmOutput } from "../lib/debug-utils.js";
+import { parseMarkdownBulletedList } from "../lib/markdown-bulleted-list-parser.js";
+import { parseLlmResponseAsProperties } from "../lib/parse-llm-response.js";
+import { createL10n } from "../site-schema-generator/create-l10n.js";
+import { createSiteSchemaFromAnalysis } from "../site-schema-generator/create-site-schema.js";
+import { invokeUpdateSiteSchema } from "./invoke-update-site-schema.js";
+export const analyzePrompt = await createPromptTemplate({
+    fileName: "new-site-1-analysis.md",
+    withSiteSchemaTsDefs: true,
+});
+const fieldsPrompt = await createPromptTemplate({
+    fileName: "new-site-2-fields.md",
+    withSiteSchemaTsDefs: true,
+});
+export async function invokeNewSiteAnalysis(ctx, input) {
+    const { analysis, explanation, unusedInformation } = await invokeAnalysisStep1(ctx, input);
+    const siteSchema = createSiteSchemaFromAnalysis(analysis);
+    await invokeAnalysisStep2(ctx, { prompt: unusedInformation ?? "" }, siteSchema);
+    reorderSiteSchemaNodeTypes(siteSchema);
+    const l10n = createL10n(analysis, siteSchema);
+    const siteTitle = {
+        [analysis.siteProperties.language]: analysis.siteProperties.title,
+    };
+    if (!unusedInformation) {
+        return {
+            siteTitle,
+            siteSchema,
+            l10n,
+            explanation,
+        };
+    }
+    ctx.logger.debug("Unused information:", unusedInformation);
+    const updated = await invokeUpdateSiteSchema(ctx, {
+        prompt: unusedInformation,
+        generatedSchema: {
+            siteTitle,
+            siteSchema,
+            l10n,
+        },
+    });
+    return {
+        siteTitle,
+        siteSchema: updated.siteSchema,
+        l10n: updated.l10n,
+        explanation: `${explanation}\n\n${updated.explanation}`,
+    };
+}
+async function invokeAnalysisStep1(ctx, input) {
+    const debugName = "analysis";
+    const llmInput = {
+        message: input.prompt,
+        siteSchemaTsDefs: getSiteSchemaTsDefs(),
+    };
+    const debug = await debugLlmOutput(ctx, debugName, ctx.goodModelName, {
+        message: llmInput.message,
+    });
+    let llmMessageContent = debug.storedContent;
+    if (!llmMessageContent) {
+        const llmMessage = await analyzePrompt.pipe(ctx.goodModel).invoke(llmInput);
+        llmMessageContent = await debug.getMessageContent(llmMessage);
+    }
+    const rawAnalysis = parseLlmResponseAsProperties(llmMessageContent, [
+        {
+            tagName: "website_properties_yaml",
+            key: "siteProperties",
+            format: "yaml",
+        },
+        {
+            tagName: "hierarchical_md",
+            key: "tree",
+            format: "markdown",
+        },
+        {
+            tagName: "dictionary_yaml",
+            key: "dictionary",
+            format: "yaml",
+        },
+        {
+            tagName: "explanation_md",
+            key: "explanation",
+            format: "markdown",
+        },
+        {
+            tagName: "unused_information_md",
+            key: "unusedInformation",
+            format: "markdown",
+            optional: true,
+        },
+    ]);
+    const tree = parseMarkdownBulletedList(rawAnalysis.tree);
+    const analysis = {
+        dictionary: rawAnalysis.dictionary,
+        siteProperties: rawAnalysis.siteProperties,
+        tree,
+    };
+    return {
+        analysis,
+        explanation: rawAnalysis.explanation,
+        unusedInformation: rawAnalysis.unusedInformation,
+    };
+}
+async function invokeAnalysisStep2(ctx, input, 
+/** Will be mutated. */
+siteSchema) {
+    const debugName = "assign-fields";
+    const llmInput = {
+        siteSchemaTsDefs: getSiteSchemaTsDefs(),
+        predefinedFields: JSON.stringify(getPredefinedFields(), undefined, 2),
+        siteSchemaJson: JSON.stringify(siteSchema, undefined, 2),
+        message: input.prompt,
+    };
+    const debug = await debugLlmOutput(ctx, debugName, ctx.goodModelName, {
+        message: llmInput.message,
+        siteSchemaJson: llmInput.siteSchemaJson,
+    });
+    let llmMessageContent = debug.storedContent;
+    if (!llmMessageContent) {
+        const llmMessage = await fieldsPrompt.pipe(ctx.goodModel).invoke(llmInput);
+        llmMessageContent = await debug.getMessageContent(llmMessage);
+    }
+    const { assignedFields } = parseLlmResponseAsProperties(llmMessageContent, [
+        {
+            tagName: "yaml_result",
+            key: "assignedFields",
+            format: "yaml",
+        },
+    ]);
+    if (siteSchema.nodeTypes) {
+        assignFieldsToNodeTypes(ctx, assignedFields, siteSchema.nodeTypes);
+    }
+}
+function assignFieldsToNodeTypes(ctx, assignedFields, nodeTypes) {
+    const remainingTypeNames = new Set(Object.keys(assignedFields));
+    for (const nodeType of nodeTypes) {
+        const typeName = nodeType.kind === "site" ? "_site" : nodeType.typeName;
+        const fieldNames = assignedFields[typeName];
+        if (!fieldNames) {
+            ctx.logger.warn(`Missing assigned fields for node type "${typeName}"`);
+            continue;
+        }
+        if (fieldNames.length > 0) {
+            nodeType.fields = fieldNames;
+        }
+        remainingTypeNames.delete(typeName);
+    }
+    if (remainingTypeNames.size > 0) {
+        ctx.logger.warn(`Field names were produced for unknown node types: ${[...remainingTypeNames].join(", ")}`);
+    }
+}
+function reorderSiteSchemaNodeTypes(siteSchema) {
+    if (!siteSchema.nodeTypes)
+        return;
+    siteSchema.nodeTypes = siteSchema.nodeTypes.map((nodeType) => reorderObjectKeys(nodeType, [
+        "typeName",
+        "kind",
+        "documentKind",
+        "route",
+        "redirectTo",
+        "ogType",
+        "withFeaturedImage",
+        "fields",
+        "lists",
+        "routingChildren",
+        "children",
+        "orderChildrenBy",
+    ]));
+}

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

@@ -0,0 +1,94 @@
+import { createPromptTemplate, getPredefinedFields, getSiteSchemaTsDefs, } from "../lib/create-prompt.js";
+import { debugLlmOutput } from "../lib/debug-utils.js";
+import { parseLlmResponseAsProperties } from "../lib/parse-llm-response.js";
+const prompt1Tpl = await createPromptTemplate({
+    fileName: "update-site-schema-1-write-details.md",
+});
+const prompt2Tpl = await createPromptTemplate({
+    fileName: "update-site-schema-2-execute.md",
+});
+export async function invokeUpdateSiteSchema(ctx, input) {
+    const task = await invokeUpdateSiteSchemaStep1(ctx, input);
+    if (!task.taskDetailsMd) {
+        // no changes
+        return {
+            ...input.generatedSchema,
+            explanation: task.explanation,
+        };
+    }
+    const genSchema = await invokeUpdateSiteSchemaStep2(ctx, {
+        taskDetailsMd: task.taskDetailsMd,
+        generatedSchema: input.generatedSchema,
+    });
+    return {
+        ...genSchema,
+        explanation: task.explanation,
+    };
+}
+async function invokeUpdateSiteSchemaStep1(ctx, input) {
+    const debugName = "update-step1";
+    const llmInput = {
+        siteSchemaTsDefs: getSiteSchemaTsDefs(),
+        siteSchemaJson: JSON.stringify(input.generatedSchema.siteSchema, undefined, 2),
+        l10nJson: JSON.stringify(input.generatedSchema.l10n, undefined, 2),
+        updateMessage: input.prompt,
+    };
+    const debug = await debugLlmOutput(ctx, debugName, ctx.goodModelName, {
+        updateMessage: llmInput.updateMessage,
+        siteSchemaJson: llmInput.siteSchemaJson,
+        l10nJson: llmInput.l10nJson,
+    });
+    let llmMessageContent = debug.storedContent;
+    if (!llmMessageContent) {
+        const llmMessage = await prompt1Tpl.pipe(ctx.goodModel).invoke(llmInput);
+        llmMessageContent = await debug.getMessageContent(llmMessage);
+    }
+    return parseLlmResponseAsProperties(llmMessageContent, [
+        {
+            tagName: "task_details_md",
+            key: "taskDetailsMd",
+            format: "markdown",
+            optional: true,
+        },
+        {
+            tagName: "explanation_md",
+            key: "explanation",
+            format: "markdown",
+        },
+    ]);
+}
+async function invokeUpdateSiteSchemaStep2(ctx, input) {
+    const debugName = "update-step2";
+    const llmInput = {
+        siteSchemaTsDefs: getSiteSchemaTsDefs(),
+        predefinedFields: JSON.stringify(getPredefinedFields(), undefined, 2),
+        siteSchemaJson: JSON.stringify(input.generatedSchema.siteSchema, undefined, 2),
+        l10nJson: JSON.stringify(input.generatedSchema.l10n, undefined, 2),
+        taskDetailsMd: input.taskDetailsMd,
+    };
+    const debug = await debugLlmOutput(ctx, debugName, ctx.goodModelName, {
+        taskDetailsMd: llmInput.taskDetailsMd,
+        siteSchemaJson: llmInput.siteSchemaJson,
+        l10nJson: llmInput.l10nJson,
+    });
+    let llmMessageContent = debug.storedContent;
+    if (!llmMessageContent) {
+        const llmMessage = await prompt2Tpl.pipe(ctx.goodModel).invoke(llmInput);
+        llmMessageContent = await debug.getMessageContent(llmMessage);
+    }
+    return {
+        ...input.generatedSchema,
+        ...parseLlmResponseAsProperties(llmMessageContent, [
+            {
+                tagName: "updated_site_schema_json",
+                key: "siteSchema",
+                format: "json",
+            },
+            {
+                tagName: "updated_labels_json",
+                key: "l10n",
+                format: "json",
+            },
+        ]),
+    };
+}

package/gen-backend/dist/generator/site-generator/common-template-creator.js

@@ -0,0 +1,108 @@
+import { getJtHomeType, getJtSiteType, isMultilingual } from "./jt-site-schema-helpers.js";
+import { indent } from "./template-helpers.js";
+export function templateOfDocumentBreadcrumb() {
+    return `{% if doc.breadcrumb %}
+  <div class="Container">
+    {% for crumb in doc.breadcrumb %}
+      <a class="TextLink" href="{{ crumb.url }}">{{ crumb.title }}</a>
+      /
+    {% endfor %}
+    {{ doc.title }}
+  </div>
+{% endif %}`;
+}
+export function templateOfSiteHeader(ctx) {
+    const content = [
+        templateOfSiteLogoTitle(ctx),
+        templateOfMainMenu(ctx),
+        templateOfSearchOpener(ctx),
+    ];
+    return `<div class="_bg2">
+  <header class="Container Header">
+    ${indent(content.filter(Boolean).join("\n"), 2, { skipFirst: true })}
+  </header>
+</div>`;
+}
+function templateOfSiteLogoTitle(ctx) {
+    const { siteSchema } = ctx;
+    const siteType = getJtSiteType(siteSchema);
+    const content = [
+        siteType.fields?.includes("logo")
+            ? `{% if site.field.logo %}
+  {% useImage logo uid: site.field.logo.uid size: "x50" %}
+  <img
+    src="{{ logo.url }}"
+    width="{{ logo.width }}"
+    height="{{ logo.height }}"
+    loading="lazy"
+    alt="">
+{% endif %}`
+            : undefined,
+        `<span class="Header-title">{{ site.field.title }}</span>`,
+    ];
+    return `<a
+  class="Header-logo"
+  href="{{ site.home.url }}"
+  data-menu-item-id="{{ site.home.id }}">
+  ${indent(content.filter(Boolean).join("\n"), 1, { skipFirst: true })}
+</a>`;
+}
+function templateOfMainMenu(ctx) {
+    const { siteSchema } = ctx;
+    const homeType = getJtHomeType(siteSchema);
+    const menuItems = homeType.routingChildren?.filter((typeName) => typeName !== "search" && typeName !== "searchPage");
+    if (!menuItems || menuItems.length === 0)
+        return;
+    const variableTemplates = menuItems.map((typeName) => `{% getDoc ${typeName} id: site.home.${typeName}.id %}`);
+    const itemTemplates = menuItems.map((typeName) => `<a
+  data-menu-item-id="{{ ${typeName}.id }}"
+  href="{{ ${typeName}.url }}">
+  {{ ${typeName}.title }}
+</a>`);
+    return `${variableTemplates.join("\n")}
+<nav data-activate-menu-items="{{ doc.id | activateMenuItemsData }}">
+  ${indent(itemTemplates.join("\n"), 1, { skipFirst: true })}
+</nav>`;
+}
+function templateOfSearchOpener(ctx) {
+    const { siteSchema } = ctx;
+    const homeType = getJtHomeType(siteSchema);
+    const typeName = homeType.routingChildren?.find((typeName) => typeName === "search" || typeName === "searchPage");
+    if (!typeName)
+        return;
+    return `{% getDoc ${typeName} id: site.home.${typeName}.id %}
+<span
+  data-effect="searchOpener"
+  data-search-url="{{ ${typeName}.url }}"
+  data-icon-color="#fff"></span>`;
+}
+export function templateOfSiteFooter(ctx) {
+    const content = [templateOfSiteFooterMention(ctx), templateOfLanguageSelector(ctx)];
+    return `<div class="_bg2">
+  <footer class="Container">
+    ${indent(content.filter(Boolean).join("\n"), 2, { skipFirst: true })}
+  </footer>
+</div>`;
+}
+function templateOfSiteFooterMention(ctx) {
+    const { siteSchema } = ctx;
+    const siteType = getJtSiteType(siteSchema);
+    if (!siteType.fields?.includes("footerMention"))
+        return;
+    return `<div class="Text">{{ site.field.footerMention | raw }}</div>`;
+}
+function templateOfLanguageSelector(ctx) {
+    const { siteSchema } = ctx;
+    if (!isMultilingual(siteSchema))
+        return;
+    return `<ul class="LanguageSelector">
+  {% for translation in doc.translations %}
+    <li>
+      <a
+        class="{% if translation.active %}active{% endif %}"
+        href="{{ translation.url }}"
+        title="{{ translation.languageLabel }}">{{ translation.language }}</a>
+    </li>
+  {% endfor %}
+</ul>`;
+}