@voicenter-team/nuxt-llms-generator 0.1.10 → 0.1.12

package/dist/chunks/llms-files-generator.mjs

@@ -3,24 +3,278 @@ import { join, dirname, basename } from 'path';
 import { slugify } from 'transliteration';
 import Mustache from 'mustache';
 import Anthropic from '@anthropic-ai/sdk';
-import { createHash } from 'crypto';
+import { encode } from '@toon-format/toon';
 import { JSONPath } from 'jsonpath-plus';
-import { w as withErrorHandling } from '../shared/nuxt-llms-generator.bc139143.mjs';
+import { createHash } from 'crypto';
+import { w as withErrorHandling } from '../shared/nuxt-llms-generator.db76a78e.mjs';
 import '@nuxt/kit';
 import 'zod';
 import 'node-html-markdown';
 
+function extractPageContent(umbracoData, jpath) {
+  try {
+    const result = JSONPath({
+      path: jpath,
+      json: umbracoData.SiteData,
+      wrap: false
+    });
+    if (!result || Array.isArray(result) && result.length === 0) {
+      return null;
+    }
+    const pageContent = Array.isArray(result) ? result[0] : result;
+    return excludeChildrenFromContent(pageContent);
+  } catch (error) {
+    console.error(`Failed to extract content for path ${jpath}:`, error);
+    return null;
+  }
+}
+function excludeChildrenFromContent(content) {
+  if (!content || typeof content !== "object") {
+    return content;
+  }
+  const cleanContent = { ...content };
+  if ("children" in cleanContent) {
+    delete cleanContent.children;
+  }
+  return cleanContent;
+}
+function generatePageId(urlItem) {
+  const templateAlias = urlItem.TemplateAlias || "UnknownTemplate";
+  const nodeID = urlItem.nodeID || "UnknownNode";
+  return `${templateAlias}_${nodeID}`;
+}
+function isImportantKey(key) {
+  const importantPatterns = [
+    "title",
+    "name",
+    "heading",
+    "description",
+    "summary",
+    "content",
+    "text",
+    "body",
+    "value",
+    "label",
+    "caption",
+    "alt",
+    "message",
+    "url",
+    "link",
+    "href"
+  ];
+  const lowerKey = key.toLowerCase();
+  return importantPatterns.some((pattern) => lowerKey.includes(pattern));
+}
+function isMetadataKey(key) {
+  const metadataPatterns = [
+    "id",
+    "guid",
+    "key",
+    "_id",
+    "nodeid",
+    "created",
+    "updated",
+    "modified",
+    "timestamp",
+    "date",
+    "sort",
+    "order",
+    "index",
+    "position",
+    "published",
+    "hidden",
+    "visible",
+    "enabled",
+    "status",
+    "type",
+    "contenttype",
+    "template",
+    "alias",
+    "path",
+    "meta",
+    "metadata",
+    "seo",
+    "schema",
+    "properties"
+  ];
+  const lowerKey = key.toLowerCase();
+  return metadataPatterns.some((pattern) => lowerKey.includes(pattern));
+}
+function recursiveTruncate(content, maxTokens, currentDepth = 0) {
+  if (currentDepth > 10) {
+    return { _truncated: "Max depth reached" };
+  }
+  if (maxTokens < 10) {
+    return void 0;
+  }
+  if (content === null || content === void 0) {
+    return content;
+  }
+  if (typeof content !== "object") {
+    if (typeof content === "string" && content.length > 2e3) {
+      return content.substring(0, 2e3) + "...";
+    }
+    return content;
+  }
+  if (Array.isArray(content)) {
+    if (content.length === 0)
+      return content;
+    const itemLimit = Math.max(3, Math.floor(15 / (currentDepth + 1)));
+    const tokensPerItem = Math.floor(maxTokens / Math.min(content.length, itemLimit));
+    const truncatedArray = content.slice(0, itemLimit).map((item) => recursiveTruncate(item, tokensPerItem, currentDepth + 1)).filter((item) => item !== void 0);
+    if (content.length > truncatedArray.length) {
+      truncatedArray.push({
+        _note: `... and ${content.length - truncatedArray.length} more items`
+      });
+    }
+    return truncatedArray;
+  }
+  const truncatedObj = {};
+  const entries = Object.entries(content);
+  const withoutMetadata = entries.filter(([key]) => !isMetadataKey(key));
+  if (withoutMetadata.length === 0) {
+    return { _note: "Only metadata, removed" };
+  }
+  const importantEntries = withoutMetadata.filter(([key]) => isImportantKey(key));
+  const normalEntries = withoutMetadata.filter(([key]) => !isImportantKey(key));
+  const importantBudget = Math.floor(maxTokens * 0.4);
+  const tokensPerImportant = importantEntries.length > 0 ? Math.floor(importantBudget / importantEntries.length) : 0;
+  for (const [key, value] of importantEntries) {
+    const processedValue = recursiveTruncate(value, tokensPerImportant, currentDepth + 1);
+    if (processedValue !== void 0) {
+      truncatedObj[key] = processedValue;
+    }
+  }
+  const usedTokens = estimateContentTokens(truncatedObj);
+  const remainingBudget = maxTokens - usedTokens;
+  if (remainingBudget > 100 && normalEntries.length > 0) {
+    const sortedNormal = normalEntries.sort(([_a, valueA], [_b, valueB]) => {
+      const sizeA = JSON.stringify(valueA).length;
+      const sizeB = JSON.stringify(valueB).length;
+      return sizeA - sizeB;
+    });
+    const tokensPerNormal = Math.floor(remainingBudget / sortedNormal.length);
+    for (const [key, value] of sortedNormal) {
+      const processedValue = recursiveTruncate(value, tokensPerNormal, currentDepth + 1);
+      if (processedValue !== void 0) {
+        truncatedObj[key] = processedValue;
+        const newSize = estimateContentTokens(truncatedObj);
+        if (newSize > maxTokens) {
+          delete truncatedObj[key];
+          break;
+        }
+      }
+    }
+  }
+  return Object.keys(truncatedObj).length > 0 ? truncatedObj : void 0;
+}
+function emergencyTruncate(content, maxTokens) {
+  const result = { ...content };
+  const keys = Object.keys(result).sort((a, b) => {
+    const aImportant = isImportantKey(a) ? 1 : 0;
+    const bImportant = isImportantKey(b) ? 1 : 0;
+    return aImportant - bImportant;
+  });
+  for (const key of keys) {
+    if (estimateContentTokens(result) <= maxTokens)
+      break;
+    delete result[key];
+    console.warn(`    Emergency: removed "${key}"`);
+  }
+  return result;
+}
+function estimateContentTokens(content) {
+  try {
+    const jsonString = JSON.stringify(content);
+    return Math.ceil(jsonString.length / 3);
+  } catch {
+    return 0;
+  }
+}
+function truncateContentIfNeeded(content, maxTokens = 1e5) {
+  const estimatedTokens = estimateContentTokens(content);
+  if (estimatedTokens <= maxTokens) {
+    return content;
+  }
+  console.warn(`\u26A0\uFE0F  Content too large (${estimatedTokens} tokens > ${maxTokens} limit), truncating recursively...`);
+  const truncatedContent = recursiveTruncate(content, maxTokens, 0);
+  const result = truncatedContent && typeof truncatedContent === "object" && !Array.isArray(truncatedContent) ? truncatedContent : {
+    _error: "Content truncation failed",
+    original: content
+  };
+  const finalTokens = estimateContentTokens(result);
+  const preservedKeys = Object.keys(result).length;
+  const originalKeys = Object.keys(content).length;
+  console.log(`\u2705 Content truncated: ${estimatedTokens} \u2192 ${finalTokens} tokens (preserved ${preservedKeys}/${originalKeys} root keys)`);
+  if (finalTokens > maxTokens) {
+    console.error(`\u274C Recursive truncation insufficient (${finalTokens} > ${maxTokens}), performing emergency truncation...`);
+    return emergencyTruncate(result, maxTokens);
+  }
+  return result;
+}
+
 function buildLLMSTemplatePrompt(request) {
+  const jsonTokens = estimateContentTokens(request.pageContent);
+  const toonData = encode(request.pageContent, { delimiter: "	" });
+  const toonTokens = estimateContentTokens(toonData);
+  console.log(`\u{1F4CA} ${request.url}: JSON ${jsonTokens} \u2192 TOON ${toonTokens} (${((1 - toonTokens / jsonTokens) * 100).toFixed(0)}% saved)`);
   return `# LLMS.txt-Optimized Mustache Template Generator
 
 You are an expert at creating **Mustache.js templates** that generate **LLM knowledge base entries** following the [\`llms.txt\` standard](https://llmstxt.org/).
 
 ---
 
+## \u26A0\uFE0F CRITICAL RULES - NEVER VIOLATE
+
+### 1. DATA-DRIVEN CONTENT ONLY
+- **EVERY piece of content** must come from a Mustache binding: \`{{propertyName}}\`
+- **NEVER invent, assume, or add content** that doesn't exist in the provided data
+- **NO hardcoded descriptions, lists, or facts**
+- If a property doesn't exist in data, don't create a section for it
+
+### 2. ALLOWED CONTEXTUAL ADDITIONS
+You MAY add:
+- **Section headings** that describe what the data represents (e.g., "Key Features", "Technical Details")
+- **Brief introductory phrases** that set context (e.g., "The following items are available:")
+- **Structural markers** for clarity (e.g., "Navigation:", "Metadata:")
+
+You MAY NOT add:
+- Descriptions of features/benefits not in data
+- Explanatory text about what something does
+- Lists of items not present in data
+- Assumptions about the page purpose
+
+### 3. UNDERSTANDING TOON FORMAT
+
+The data below is in **TOON format** (Token-Oriented Object Notation) for efficiency.
+
+**How to read TOON:**
+- \`propertyName: value\` \u2192 Single property
+- \`array[3]{prop1,prop2}\` \u2192 Array of 3 objects with properties prop1, prop2
+- Properties in \`{braces}\` are the **exact field names** to use in Mustache bindings
+
+**Example:**
+\`\`\`toon
+users[2]{id,name,role}:
+  1	Alice	admin
+  2	Bob	user
+\`\`\`
+
+**Your Mustache template:**
+\`\`\`mustache
+{{#users}}
+- {{id}}: {{name}} ({{role}})
+{{/users}}
+\`\`\`
+
+**CRITICAL:** Use the EXACT property names shown in TOON \`{braces}\` for your Mustache bindings.
+
+---
+
 ## \u{1F3AF} TRUE PURPOSE: Help LLMs Answer Questions Efficiently
 
 **Critical Understanding:**
-These \`.md\` files are **NOT website copies** \u2014 they are **LLM knowledge base entries** designed for **inference** (understanding), not training.
+These \`.md\` files are **LLM knowledge base entries** designed for **inference** (understanding), not training.
 
 **Primary Goal:** Enable LLMs to quickly answer user questions about this website page within **limited context windows** (typically 200K tokens).
 
@@ -38,94 +292,102 @@ These \`.md\` files are **NOT website copies** \u2014 they are **LLM knowledge b
 - **Template Alias:** ${request.templateAlias}
 - **JSON Path:** ${request.jpath}
 
-### Available Data
-\`\`\`json
-${JSON.stringify(request.pageContent, null, 2)}
+### Available Data (TOON Format)
+
+\`\`\`toon
+${toonData}
 \`\`\`
 
 ---
 
 ## \u{1F9E0} Content Philosophy: Think "Knowledge Base Entry"
 
-### 1. Start with Expert-Level Summary
-- **First impression matters:** What would an expert say about this page in 1-2 sentences?
-- Lead with **value proposition** or **core purpose**
-- Use the blockquote format (\`> \`) for the summary \u2014 this signals importance
+### 1. Start with the Most Important Data
+- Lead with title/heading properties
+- Add main description/summary if available
+- Use blockquote (\`> \`) for key summaries
 
 ### 2. Structure for Question-Answering
 Anticipate questions an LLM might need to answer:
-- "What is this?" \u2192 Main heading + summary
-- "What does it do/offer?" \u2192 Key features/benefits section
-- "Who is it for?" \u2192 Target audience/use cases
-- "How does it work?" \u2192 Process/methodology
-- "What are the details?" \u2192 Technical specs/pricing/etc.
+- "What is this?" \u2192 Main heading + description properties
+- "What does it offer?" \u2192 Lists of items/features from data
+- "Who is it for?" \u2192 Target audience properties (if they exist)
+- "What are the details?" \u2192 Technical/metadata properties
 
-### 3. Prioritize Information by Importance
+### 3. Prioritize by Data Importance
 **Essential First:**
-- What this page represents
-- Primary value/purpose
-- Key differentiators
+- Title/name/heading properties
+- Description/summary properties
+- Main content arrays
 
 **Supporting Details Second:**
-- Features, benefits, specifications
-- Use cases, examples
-- Technical details
+- Feature lists, item arrays
+- Nested objects with details
+- Links and references
 
-**Peripheral Information Last:**
-- Meta information, related links
-- Supplementary context
+**Metadata Last:**
+- URLs, IDs (if useful for context)
+- Timestamps, technical details
 
 ### 4. Optimize for Scanability
-- Use **hierarchical headings** (\`#\`, \`##\`, \`###\`) to create clear structure
-- Employ **bullet lists** for scannable facts
-- Keep paragraphs **short and dense** (2-3 sentences max)
-- Use **semantic Markdown** only \u2014 no HTML, entities, or attributes
+- Use **hierarchical headings** (\`#\`, \`##\`, \`###\`)
+- Employ **bullet lists** for arrays
+- Keep structure **clean and semantic**
+- Use Markdown only (no HTML)
 
 ---
 
 ## \u{1F527} Technical Principles (Key-Agnostic Design)
 
-### 1. Dynamic Property Inference
-**Do not assume fixed property names.** Infer content type and importance from:
-- **Value structure:** Object, array, string, number
-- **Value length:** Short strings = titles; long text = descriptions
-- **Position in JSON:** Root-level = high importance; nested = contextual details
-- **Semantic patterns:** URLs, images, dates, IDs
+### 1. Extract Property Names from TOON
+Look at TOON headers to identify properties:
+- \`{id,name,role}\` \u2192 Use \`{{id}}\`, \`{{name}}\`, \`{{role}}\`
+- \`breadcrumbsLinks[5]{title,link}\` \u2192 Use \`{{#breadcrumbsLinks}}{{title}} {{link}}{{/breadcrumbsLinks}}\`
 
 ### 2. Exact Property Bindings
-- Always use the **exact property name** from JSON: \`{{actualKeyName}}\`
+- Always use **exact property name** from TOON: \`{{actualKeyName}}\`
 - Do NOT rename or modify binding identifiers
-- The Mustache bindings must match JSON precisely
+- Mustache bindings must match TOON property names precisely
 
 ### 3. Humanized Section Headings
 While bindings stay exact, convert keys to readable headings:
 - \`productFeatures\` \u2192 "Product Features"
-- \`pricing_tiers\` \u2192 "Pricing Tiers"
-- \`techSpecs\` \u2192 "Technical Specifications"
-
-### 4. Semantic Interpretation Guide
-- **Short root strings (5-50 chars)** \u2192 Likely page title
-- **Medium text (50-300 chars)** \u2192 Likely summary/tagline
-- **Long text (300+ chars)** \u2192 Likely detailed description
-- **Arrays of primitives** \u2192 Bullet lists
-- **Arrays of objects** \u2192 Repeated sections or tables
-- **Nested objects** \u2192 Sub-sections with logical hierarchy
-- **URL-like strings** \u2192 Render as \`[Label]({{url}})\`
-- **Image URLs** \u2192 Render as \`![Description]({{imageUrl}})\`
+- \`supportPageItems\` \u2192 "Available Support Topics"
+- \`breadcrumbsLinks\` \u2192 "Navigation Path"
+
+### 4. Working with Arrays
+When you see \`arrayName[N]{prop1,prop2}\`:
+- Use \`{{#arrayName.0}}\` to check if array exists
+- Iterate with \`{{#arrayName}}\`
+- Access properties with \`{{prop1}}\`, \`{{prop2}}\`
+
+**Example:**
+\`\`\`toon
+items[3]{title,description}:
+  ...
+\`\`\`
+\u2192
+\`\`\`mustache
+{{#items.0}}
+## Items
+{{#items}}
+- {{title}}: {{description}}
+{{/items}}
+{{/items.0}}
+\`\`\`
 
 ### 5. Noise Filtering
-**Exclude non-content fields:**
-- IDs (\`id\`, \`nodeId\`, \`_id\`)
-- Timestamps (\`createdAt\`, \`updatedAt\`, \`lastModified\`)
-- Internal flags (\`isPublished\`, \`sortOrder\`, \`hidden\`)
-- System metadata (\`_type\`, \`contentType\`, \`template\`)
+**Exclude technical metadata** (if present in TOON):
+- IDs: \`id\`, \`nodeId\`, \`_id\`, \`guid\`
+- Timestamps: \`createdAt\`, \`updatedAt\`
+- Flags: \`isPublished\`, \`sortOrder\`, \`hidden\`
+- System: \`_type\`, \`contentType\`
 
 ### 6. Hierarchy & Nesting
 - **Root level** \u2192 \`#\` (H1) \u2014 one per document
 - **Primary sections** \u2192 \`##\` (H2)
 - **Sub-sections** \u2192 \`###\` (H3)
-- **Details** \u2192 \`####\` (H4) \u2014 avoid going deeper
-- Heading depth corresponds to JSON nesting, but stay practical
+- **Details** \u2192 \`####\` (H4) \u2014 avoid deeper
 
 ---
 
@@ -133,66 +395,122 @@ While bindings stay exact, convert keys to readable headings:
 
 ### Mandatory Opening
 \`\`\`mustache
-# {{primaryTitle}}
+# {{primaryTitleProperty}}
 
-{{#summaryOrTagline}}
-> {{summaryOrTagline}}
-{{/summaryOrTagline}}
+{{#summaryProperty}}
+> {{summaryProperty}}
+{{/summaryProperty}}
 \`\`\`
 
-### Recommended Sections (adapt to JSON)
+### Example Sections (adapt to actual TOON data)
 \`\`\`mustache
 {{#mainDescription}}
+## Overview
 {{mainDescription}}
 {{/mainDescription}}
 
-{{#keyFeatures.0}}
-## Key Features
-{{#keyFeatures}}
-- **{{featureName}}**: {{featureDescription}}
-{{/keyFeatures}}
-{{/keyFeatures.0}}
-
-{{#useCases.0}}
-## Use Cases
-{{#useCases}}
-### {{caseTitle}}
-{{caseDescription}}
-{{/useCases}}
-{{/useCases.0}}
-
-{{#technicalDetails.0}}
-## Technical Details
-{{#technicalDetails}}
-- **{{detailLabel}}**: {{detailValue}}
-{{/technicalDetails}}
-{{/technicalDetails.0}}
+{{#itemsArray.0}}
+## Available Items
+{{#itemsArray}}
+### {{itemTitle}}
+{{itemDescription}}
+{{/itemsArray}}
+{{/itemsArray.0}}
+
+{{#navigationLinks.0}}
+## Navigation
+{{#navigationLinks}}
+- [{{title}}]({{link}})
+{{/navigationLinks}}
+{{/navigationLinks.0}}
 \`\`\`
 
-**Note:** This is an illustrative pattern. Adapt section names and structure to match the actual JSON dynamically.
+**Important:** These are examples. Your template must match the ACTUAL TOON structure provided.
 
 ---
 
 ## \u2705 Output Requirements
 
-1. **Output ONLY the Mustache template** \u2014 no explanations, no code fences, no preamble
-2. **Use exact JSON property names** in all bindings
+1. **Output ONLY the Mustache template** \u2014 no explanations, no markdown code fences, no preamble
+2. **Use exact property names from TOON \`{braces}\`** in all bindings
 3. **Generate clean Markdown** \u2014 no HTML, entities, or attributes
-4. **Prioritize content** \u2014 most important information first
-5. **Be concise** \u2014 optimize for limited context windows
-6. **Structure for questions** \u2014 LLMs should easily extract facts
-7. **Stay domain-agnostic** \u2014 template should work for any JSON shape
+4. **Data-driven content** \u2014 no invented facts or descriptions
+5. **Contextual headings allowed** \u2014 but content must be from data
+6. **Be concise** \u2014 optimize for limited context windows
+7. **Structure for questions** \u2014 LLMs should easily extract facts
+
+---
+
+## \u26A0\uFE0F CRITICAL: Mustache Syntax Validation
+
+**Every \`{{#tag}}\` MUST have matching \`{{/tag}}\`**
+
+### Common Errors (from real failures):
+
+\u274C **Missing closing tag:**
+\`\`\`mustache
+{{#pageDescription}}
+  content
+// \u274C Missing {{/pageDescription}}
+\`\`\`
+
+\u274C **Nested check without outer closing:**
+\`\`\`mustache
+{{#items.0}}
+  {{#items}}...{{/items}}
+// \u274C Missing {{/items.0}}
+\`\`\`
+
+\u274C **Capitalization mismatch:**
+\`\`\`mustache
+{{#aIFeaturesCTATitle}}
+  ...
+{{/aiFeaturesCTATitle}}  \u274C Different capitalization!
+\`\`\`
+
+### Validation Checklist:
+
+**Before output:**
+1. Count \`{{#\` tags = ___
+2. Count \`{{/\` tags = ___
+3. Numbers match? If NO \u2192 Find and add missing closing tags
+4. Tag names exact match (including dots, numbers, capitalization)?
+
+\u2705 **Valid example:**
+\`\`\`mustache
+{{#section}}         \u2190 1 open
+  {{#nested.0}}      \u2190 2 open
+    content
+  {{/nested.0}}      \u2190 2 close
+{{/section}}         \u2190 1 close
+\`\`\`
+Count: 2 = 2 \u2713
 
 ---
 
 ## \u{1F680} Your Task
 
-Analyze the provided JSON structure and **generate a Mustache template** that produces an **LLM knowledge base entry** following these principles.
+Analyze the provided TOON data structure and **generate a Mustache template** that:
+
+1. **Uses ONLY data from TOON** (no invented content)
+2. **Extracts exact property names from \`{braces}\`**
+3. **Adds logical section headings** for context
+4. **Structures data for question-answering**
+5. **Prioritizes most important properties first**
+6. **Remains universal** (works for any data shape)
+7. **\u2705 ALL Mustache tags properly closed**
+
+**Remember:**
+- Parse TOON structure naturally \u2705
+- Use exact property names from \`{braces}\` \u2705\u2705\u2705
+- Headings can be contextual \u2705
+- Content must be from data \u2705\u2705\u2705
+- No made-up descriptions \u274C
+- No assumed features \u274C
+- **Every {{#tag}} has {{/tag}}** \u2705\u2705\u2705
 
-**Think:**
-- What would an LLM need to know to answer questions about this page?
-- What's the core value/purpose this page communicates?
-- How can I structure this for maximum inference efficiency?
+**Final Step Before Output:**
+Count your \`{{#\` and \`{{/\` tags. If numbers don't match, find and add missing closing tags.
 
 Generate the template now.
 `;
@@ -216,7 +534,7 @@ class AnthropicClient {
         const response = await this.client.messages.create({
           model: this.model,
           max_tokens: 4e3,
-          temperature: 0.1,
+          temperature: 0.3,
           messages: [{
             role: "user",
             content: prompt
@@ -662,76 +980,6 @@ function getValueType(value) {
   return typeof value;
 }
 
-function extractPageContent(umbracoData, jpath) {
-  try {
-    const result = JSONPath({
-      path: jpath,
-      json: umbracoData.SiteData,
-      wrap: false
-    });
-    if (!result || Array.isArray(result) && result.length === 0) {
-      return null;
-    }
-    const pageContent = Array.isArray(result) ? result[0] : result;
-    return excludeChildrenFromContent(pageContent);
-  } catch (error) {
-    console.error(`Failed to extract content for path ${jpath}:`, error);
-    return null;
-  }
-}
-function excludeChildrenFromContent(content) {
-  if (!content || typeof content !== "object") {
-    return content;
-  }
-  const cleanContent = { ...content };
-  if ("children" in cleanContent) {
-    delete cleanContent.children;
-  }
-  return cleanContent;
-}
-function generatePageId(urlItem) {
-  const templateAlias = urlItem.TemplateAlias || "UnknownTemplate";
-  const nodeID = urlItem.nodeID || "UnknownNode";
-  return `${templateAlias}_${nodeID}`;
-}
-function estimateContentTokens(content) {
-  try {
-    const jsonString = JSON.stringify(content);
-    return Math.ceil(jsonString.length / 4);
-  } catch {
-    return 0;
-  }
-}
-function truncateContentIfNeeded(content, maxTokens = 18e4) {
-  const estimatedTokens = estimateContentTokens(content);
-  if (estimatedTokens <= maxTokens) {
-    return content;
-  }
-  console.warn(`Content too large (${estimatedTokens} tokens > ${maxTokens} limit), truncating...`);
-  const truncatedContent = { ...content };
-  const sortedKeys = Object.keys(truncatedContent).sort((a, b) => {
-    const sizeA = estimateContentTokens({ [a]: truncatedContent[a] });
-    const sizeB = estimateContentTokens({ [b]: truncatedContent[b] });
-    return sizeB - sizeA;
-  });
-  for (const key of sortedKeys) {
-    if (estimateContentTokens(truncatedContent) <= maxTokens) {
-      break;
-    }
-    const value = truncatedContent[key];
-    if (Array.isArray(value) && value.length > 10) {
-      truncatedContent[key] = value.slice(0, 10);
-      console.warn(`Truncated array ${key} from ${value.length} to 10 items`);
-    } else if (typeof value === "string" && value.length > 5e3) {
-      truncatedContent[key] = value.substring(0, 5e3) + "...";
-      console.warn(`Truncated string ${key} from ${value.length} to 5000 chars`);
-    }
-  }
-  const finalTokens = estimateContentTokens(truncatedContent);
-  console.log(`Content truncated from ${estimatedTokens} to ${finalTokens} tokens`);
-  return truncatedContent;
-}
-
 function shouldGenerateTemplate(umbracoData, urlItem) {
   try {
     const pageContent = extractPageContent(umbracoData, urlItem.Jpath);
@@ -1067,7 +1315,7 @@ class TemplateGenerator {
     const pageId = generatePageId(urlItem);
     console.log(`Generating new template for ${pageId} (${urlItem.url})`);
     const tokensBeforeTruncation = estimateContentTokens(pageContent);
-    const truncatedContent = truncateContentIfNeeded(pageContent, 18e4);
+    const truncatedContent = truncateContentIfNeeded(pageContent, this.config.maxTokens);
     const tokensAfterTruncation = estimateContentTokens(truncatedContent);
     if (tokensBeforeTruncation > tokensAfterTruncation) {
       console.warn(`Page ${pageId} content truncated: ${tokensBeforeTruncation} -> ${tokensAfterTruncation} tokens`);