@paroicms/site-generator-plugin 0.8.1 → 0.9.0

package/gen-backend/dist/commands/actions.js

@@ -0,0 +1,49 @@
+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 } = verifySessionToken(commandCtx, input.sessionToken);
+    const ctx = {
+        ...commandCtx,
+        sessionId,
+    };
+    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",
+    };
+}

package/gen-backend/dist/errors.js

@@ -0,0 +1,20 @@
+/**
+ * Custom API error class for handling API-specific errors
+ */
+export class ApiError extends Error {
+    statusCode;
+    constructor(message, statusCode = 400) {
+        super(message);
+        this.name = "ApiError";
+        this.statusCode = statusCode;
+    }
+}
+/**
+ * Create a new API error
+ * @param message Error message
+ * @param statusCode HTTP status code (default: 400)
+ * @returns ApiError instance
+ */
+export function createApiError(message, statusCode = 400) {
+    return new ApiError(message, statusCode);
+}

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

@@ -0,0 +1,45 @@
+import { invokeMessageGuard } from "./llm-queries/invoke-message-guard.js";
+import { invokeNewSiteAnalysis } from "./llm-queries/invoke-new-site-analysis.js";
+import { invokeUpdateSiteSchema } from "./llm-queries/invoke-update-site-schema.js";
+import { newSession, verifySessionToken } from "./session/generator-session.js";
+import { generateSite } from "./site-generator/site-generator.js";
+export async function executeCommand(ctx, input) {
+    if (input.command === "newSession") {
+        return {
+            success: true,
+            result: await newSession(ctx, input),
+        };
+    }
+    verifySessionToken(input.sessionToken);
+    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",
+    };
+}

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

@@ -0,0 +1,51 @@
+import { getRandomImagePath } from "../lib/images-lib.js";
+export function augmentWithComputedValues(list, nodeType, language) {
+    if (!nodeType.fields)
+        return;
+    for (const item of list) {
+        for (const f of nodeType.fields) {
+            const languageKey = f.storedOn === "node" ? "." : language;
+            if (f.storedAs === "mediaHandle") {
+                const value = getMediaGeneratedFieldContent(f, language);
+                if (value) {
+                    item[f.name] = value;
+                }
+            }
+            else {
+                const value = getDefaultValueForField(f.name);
+                if (value !== undefined) {
+                    item[f.name] = { [languageKey]: value };
+                }
+            }
+        }
+    }
+}
+function getMediaGeneratedFieldContent(f, language) {
+    const languageKey = f.storedOn === "node" ? "." : language;
+    if (f.dataType === "media") {
+        return { [languageKey]: { file: getRandomImagePath() } };
+    }
+    if (f.dataType === "gallery") {
+        return {
+            [languageKey]: {
+                files: [
+                    getRandomImagePath(),
+                    getRandomImagePath(),
+                    getRandomImagePath(),
+                    getRandomImagePath(),
+                    getRandomImagePath(),
+                    getRandomImagePath(),
+                ],
+            },
+        };
+    }
+}
+function getDefaultValueForField(fieldName) {
+    if (fieldName === "phone" || fieldName === "phone2")
+        return "0123456789";
+    if (fieldName === "phones")
+        return JSON.stringify(["0123456789", "9876543210"]);
+    if (fieldName === "updateDateTime")
+        return new Date().toISOString();
+    return undefined;
+}

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

@@ -0,0 +1,33 @@
+import jwt from "jsonwebtoken";
+import { createApiError } from "../errors.js";
+const JWT_SECRET = "init"; // Hardcoded JWT secret as specified
+/**
+ * Verifies a session token and returns the session ID if valid
+ * @param token The JWT token to verify
+ * @returns The session ID contained in the token
+ * @throws ApiError if the token is invalid or expired
+ */
+export function verifySessionToken(token) {
+    try {
+        // Verify and decode the token
+        const payload = jwt.verify(token, JWT_SECRET);
+        if (!payload || !payload.sessionId) {
+            throw createApiError("Invalid session token", 401);
+        }
+        return payload.sessionId;
+    }
+    catch (error) {
+        if (error.name === "TokenExpiredError") {
+            throw createApiError("Session token expired", 401);
+        }
+        else if (error.name === "JsonWebTokenError") {
+            throw createApiError("Invalid session token", 401);
+        }
+        // Re-throw our custom error
+        if (error.name === "ApiError") {
+            throw error;
+        }
+        // Unexpected error
+        throw createApiError("Session verification failed", 500);
+    }
+}

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

@@ -0,0 +1 @@
+export {};

package/gen-backend/dist/generator/lib/token-tracking.js

@@ -0,0 +1,118 @@
+// Default limits if not specified in configuration
+const DEFAULT_REQUEST_TOKENS = 8000;
+const DEFAULT_SESSION_TOKENS = 32000;
+const DEFAULT_DAILY_TOKENS = 100000;
+/**
+ * Initialize token tracking for a session
+ */
+export function initTokenTracking(pluginConf) {
+    const requestLimit = pluginConf.maxRequestTokens ?? DEFAULT_REQUEST_TOKENS;
+    const sessionLimit = pluginConf.maxSessionTokens ?? DEFAULT_SESSION_TOKENS;
+    return {
+        requestLimit,
+        sessionLimit,
+        sessionUsage: 0,
+        userLimits: new Map(),
+    };
+}
+/**
+ * Roughly estimate token count from text length
+ * This is a simple approximation - for production, use a proper tokenizer
+ */
+export function estimateTokenCount(text) {
+    // Rough estimate: 1 token ≈ 4 characters for English text
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Track token usage for the current user
+ */
+export function trackUserTokens(ctx, tokenCount) {
+    const { userKey, tokenUsage, logger } = ctx;
+    const dailyLimit = ctx.pluginConf.maxDailyTokens ?? DEFAULT_DAILY_TOKENS;
+    // Update session usage
+    tokenUsage.sessionUsage += tokenCount;
+    // Get or create user usage entry
+    let userUsage = tokenUsage.userLimits.get(userKey);
+    if (!userUsage) {
+        userUsage = {
+            dailyUsage: 0,
+            lastReset: new Date(),
+            totalRequests: 0,
+        };
+        tokenUsage.userLimits.set(userKey, userUsage);
+    }
+    // Reset daily usage if it's a new day
+    const today = new Date().toDateString();
+    if (userUsage.lastReset.toDateString() !== today) {
+        logger.info(`Resetting daily token usage for user ${userKey}`);
+        userUsage.dailyUsage = 0;
+        userUsage.lastReset = new Date();
+    }
+    // Update daily usage
+    userUsage.dailyUsage += tokenCount;
+    userUsage.totalRequests++;
+    // Log usage
+    logger.debug(`Token usage - User: ${userKey}, Request: ${tokenCount}, ` +
+        `Session: ${tokenUsage.sessionUsage}/${tokenUsage.sessionLimit}, ` +
+        `Daily: ${userUsage.dailyUsage}/${dailyLimit}`);
+}
+/**
+ * Check if token limits have been exceeded
+ * @throws Error if any limit is exceeded
+ */
+export function checkTokenLimits(ctx, estimatedTokens) {
+    const { tokenUsage, userKey, logger } = ctx;
+    const dailyLimit = ctx.pluginConf.maxDailyTokens ?? DEFAULT_DAILY_TOKENS;
+    // Check single request limit
+    if (estimatedTokens > tokenUsage.requestLimit) {
+        logger.warn(`User ${userKey} exceeded request token limit: ${estimatedTokens}/${tokenUsage.requestLimit}`);
+        throw new Error(`Prompt exceeds maximum token limit of ${tokenUsage.requestLimit}`);
+    }
+    // Check session limit
+    if (tokenUsage.sessionUsage + estimatedTokens > tokenUsage.sessionLimit) {
+        logger.warn(`User ${userKey} exceeded session token limit: ${tokenUsage.sessionUsage}/${tokenUsage.sessionLimit}`);
+        throw new Error("Session token limit exceeded. Please start a new session.");
+    }
+    // Check daily limit
+    const userUsage = tokenUsage.userLimits.get(userKey);
+    if (userUsage && userUsage.dailyUsage + estimatedTokens > dailyLimit) {
+        logger.warn(`User ${userKey} exceeded daily token limit: ${userUsage.dailyUsage}/${dailyLimit}`);
+        throw new Error("Daily token limit exceeded. Please try again tomorrow.");
+    }
+}
+/**
+ * Safe wrapper for LLM invocation with token tracking and limits
+ */
+export async function invokeWithTokenLimit(ctx, model, prompt, processor) {
+    // For text prompts, estimate tokens
+    let promptTokens = 0;
+    if (typeof prompt === "string") {
+        promptTokens = estimateTokenCount(prompt);
+    }
+    else if (prompt.message && typeof prompt.message === "string") {
+        promptTokens = estimateTokenCount(prompt.message);
+    }
+    else {
+        // JSON objects are harder to estimate; use a conservative approach
+        promptTokens = estimateTokenCount(JSON.stringify(prompt)) * 1.5;
+    }
+    // Check limits before making the call
+    checkTokenLimits(ctx, promptTokens);
+    // Make the LLM call
+    const response = await model.invoke(prompt);
+    // Estimate response tokens and track total
+    let responseContent = "";
+    if (typeof response.content === "string") {
+        responseContent = response.content;
+    }
+    else if (response.content && response.content.length > 0) {
+        // Handle array response
+        responseContent = response.content.join("\n");
+    }
+    const responseTokens = estimateTokenCount(responseContent);
+    const totalTokens = promptTokens + responseTokens;
+    // Track the usage
+    trackUserTokens(ctx, totalTokens);
+    // Process and return the response
+    return processor(response);
+}

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

@@ -0,0 +1,33 @@
+import { ApiError } from "@paroicms/public-server-lib";
+import { nanoid } from "nanoid";
+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" });
+    return { token };
+}
+/**
+ * Verifies a session token and returns the session ID if valid
+ */
+export function verifySessionToken(token) {
+    let payload;
+    try {
+        payload = verify(token, JWT_SECRET);
+    }
+    catch (error) {
+        if (error.name === "TokenExpiredError")
+            throw new ApiError("Session token expired", 401);
+        if (error.name === "JsonWebTokenError")
+            throw new ApiError("Invalid session token", 401);
+        throw error;
+    }
+    if (!payload || !payload.sessionId)
+        throw new ApiError("Invalid session token", 401);
+    return payload.sessionId;
+}

package/gen-backend/dist/generator/session/session-command.js

@@ -0,0 +1,17 @@
+import { ApiError } from "@paroicms/public-server-lib";
+import { nanoid } from "nanoid";
+const { sign, verify } = (await import("jsonwebtoken")).default;
+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", {
+            status: 400,
+        });
+    }
+    const sessionId = nanoid();
+    const token = sign({ sessionId }, "init", // Hardcoded JWT secret as specified
+    { expiresIn: "1h" });
+    return { token };
+}

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

@@ -0,0 +1,262 @@
+export function getThemeCssContent() {
+    return `/* Reset */
+* {
+  box-sizing: border-box;
+}
+
+a,
+a:visited {
+  color: inherit;
+  text-decoration: none;
+}
+
+/* Elements */
+
+body {
+  background-color: #aaa;
+  margin: 0;
+  padding: 0;
+}
+
+img {
+  display: block;
+  max-width: 100%;
+}
+
+picture {
+  display: block;
+}
+
+/* Tile */
+
+a > article {
+  background-color: #fff;
+  border-radius: 6px;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+  display: flex;
+  max-width: 340px;
+  overflow: hidden;
+}
+a > article div:first-child {
+  flex: 0 0 120px;
+  max-width: 120px;
+}
+a > article img {
+  height: 100%;
+  object-fit: cover;
+  width: 100%;
+}
+a > article div:last-child {
+  display: flex;
+  flex: 1;
+  flex-direction: column;
+  padding: 15px;
+}
+a > article h3 {
+  margin: 0 0 8px;
+  font-size: 16px;
+  font-weight: bold;
+  color: #333;
+}
+a > article p {
+  color: #666;
+  font-size: 14px;
+  line-height: 1.4;
+  margin: 0;
+}
+
+a:hover > article {
+  box-shadow: 0 0 20px rgba(0, 0, 0, 0.15);
+}
+
+/* Classes */
+
+._bg2 {
+  background-color: #444;
+  color: #eee;
+}
+
+.Container {
+  max-width: 1200px;
+  margin: 0 auto;
+  padding: 0 20px;
+}
+
+.Page {
+  background-color: #fff;
+  color: #333;
+  padding: 5px 40px;
+}
+
+.TextWidth {
+  max-width: 600px;
+  margin: 0 auto;
+}
+
+.List {
+  display: flex;
+  gap: 20px;
+  flex-wrap: wrap;
+}
+
+.Header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding-bottom: 15px;
+  padding-top: 15px;
+  color: #fff;
+}
+
+@media (max-width: 768px) {
+  .Header {
+    flex-wrap: wrap;
+    padding: 15px 0 5px;
+  }
+}
+
+.Header-logo {
+  display: flex;
+  align-items: center;
+}
+
+.Header-logo img {
+  margin-right: 10px;
+  border-radius: 50%;
+}
+
+.Header-title {
+  font-size: 20px;
+  font-weight: bold;
+}
+
+.Header-search {
+  padding: 0 10px;
+}
+
+.Text::after {
+  clear: both;
+  content: "";
+  display: block;
+}
+
+.Text .Img {
+  height: auto;
+}
+
+.Text .Img.left {
+  float: left;
+  margin: 5px 20px 10px 0;
+}
+
+.Text .Img.right {
+  float: right;
+  margin: 5px 0 10px 20px;
+}
+
+.Text .Img.left, .Text .Img.right {
+  max-width: 50%;
+}
+
+.Text .Img.center {
+  display: block;
+  margin: 20px auto;
+}
+
+.Text a,
+.Text a:visited,
+.TextLink,
+.TextLink:visited {
+  color: #007bff;
+  cursor: pointer;
+  text-decoration: underline;
+}
+
+.Hero img {
+  height: auto;
+  width: 100%;
+}
+
+.InfiniteLoading-actionArea {
+  align-items: center;
+  display: flex;
+  justify-content: center;
+}
+
+.Button,
+.SearchOpenerBtn,
+.InfiniteLoading-btn {
+  background-color: #3498db;
+  border: 1px solid #3498db;
+  border-radius: 5px;
+  color: #fff;
+  cursor: pointer;
+  display: inline-block;
+  font-size: 16px;
+  margin: 10px 0;
+  padding: 10px 20px;
+  text-align: center;
+  text-decoration: none;
+}
+.Button:hover,
+.SearchOpenerBtn:hover,
+.InfiniteLoading-btn:hover {
+  background-color: #2980b9;
+  border-color: #2980b9;
+}
+
+.SearchOpenerBtn {
+  display: flex;
+}
+
+.Navbar {
+  align-items: center;
+  display: flex;
+  flex-grow: 1;
+  justify-content: center;
+  margin: 0 15px;
+}
+
+@media (max-width: 768px) {
+  .Navbar {
+    flex-basis: 100%;
+    order: 3;
+    margin: 10px 0 5px;
+    justify-content: flex-start;
+    overflow-x: auto;
+    padding-bottom: 5px;
+  }
+}
+
+.NavButton {
+  color: rgba(255, 255, 255, 0.85);
+  padding: 8px;
+  margin: 0 4px;
+  border-radius: 4px;
+  font-size: 17px;
+  font-weight: bold;
+  position: relative;
+  transition: all 0.2s ease;
+}
+
+.NavButton:hover {
+  color: #fff;
+  background-color: rgba(255, 255, 255, 0.1);
+}
+
+.NavButton.active {
+  color: #fff;
+}
+
+.NavButton.active::after {
+  content: "";
+  position: absolute;
+  bottom: 0;
+  left: 16px;
+  right: 16px;
+  height: 3px;
+  background-color: #3498db;
+  border-radius: 1.5px;
+}
+`;
+}

package/gen-backend/dist/lib/generator-context.js

@@ -0,0 +1,14 @@
+export function createCommandContext(service, pluginConf, rawContext) {
+    const packConf = service.connector.getSitePackConf(pluginConf.packName);
+    const { sitesDir, packName } = packConf;
+    if (!sitesDir) {
+        throw new Error(`Site-generator plugin can generate sites only for pack with "sitesDir", but pack "${packName}" doesn't have it`);
+    }
+    return {
+        ...rawContext,
+        sitesDir,
+        packName,
+        service,
+        logger: service.logger,
+    };
+}

package/gen-backend/prompts/0-context.md

@@ -6,4 +6,6 @@ A document always has the following base attributes: a localized _title_, a _pub
 
 A document can contain lists of **parts**. A _part_ is a sub-section of a document, or of another _part_. A part always has a _publish date_ and a _draft_ flag. It may contain a sequence of fields and/or a sequence of child parts. A part is always an item of a list.
 
-Any routing document which is parent of regular documents can be used as a **taxonomy**. Then, the terms are the regular child documents. Then a taxonomy can be used in any document or part, by declaring a **labeling field**.
+Any routing document which is parent of regular documents can be used as a **taxonomy**. Then, the terms are the regular child documents. Then a taxonomy can be used in any document or part, by declaring a **labeling field**.
+
+Documents and parts are **nodes** in a tree. Children are part of the definition of a node type. When 2 node types appear identical, but their children types are not the same, then they are 2 different node types and they should have 2 different names.

package/gen-backend/prompts/new-site-1-analysis.md

@@ -30,16 +30,17 @@ For this second step, follow these instructions for creating the bullet list:
 
 1. Carefully read and analyze the website description.
 2. Identify the main documents and parts of the website.
-  - Notice: Children are part of the definition of a node type. When 2 node types appear identical, but their children types are not the same, then they are 2 different node types and they should have 2 different names.
 3. Determine the hierarchical relationships between documents and parts.
 4. Create a tree structure using a limited Markdown format to represent the website's tree structure.
 
+Whenever you have a choice, keep it simple. If the user is not directive, if he gives a general and vague instruction, for example with a short prompt like “create a blog”, then limit the site sections to two main entries (in the example of a blog, a list of posts and a list of pages). Plus the usual contact and search pages.
+
 Guidelines for creating the hierarchical bullet list:
 
 - Write in English.
   - But, if the website description is not in English: do not translate book or post titles.
 - Use a Markdown syntax. Indent with 2 spaces. Use indentation to show parent-child relationships between node types.
-- Always include a homepage with key `home` at the top level.
+- Always start with the homepage, with key `home` at the top level.
 - When you define an identifier for a node type name or a list name, use camel case and follow the identifier syntax of JavaScript.
   - Use `contactPage` as the default type name for contact page, and `searchPage` for the search page.
 - Bullet point format for a _routing document_: