@voicenter-team/nuxt-llms-generator 0.1.0

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

@@ -0,0 +1,1513 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import Mustache from 'mustache';
+import Anthropic from '@anthropic-ai/sdk';
+import { createHash } from 'crypto';
+import { JSONPath } from 'jsonpath-plus';
+import { T as TemplateError, E as ErrorCode, w as withErrorHandling } from '../shared/nuxt-llms-generator.dc009f50.mjs';
+import '@nuxt/kit';
+import 'zod';
+
+class AnthropicClient {
+  client;
+  model;
+  maxRetries = 3;
+  retryDelayMs = 1e3;
+  constructor(config) {
+    this.client = new Anthropic({
+      apiKey: config.anthropicApiKey
+    });
+    this.model = config.anthropicModel || "claude-3-5-sonnet-20241022";
+  }
+  async generateTemplate(request) {
+    const prompt = this.buildPrompt(request);
+    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+      try {
+        const response = await this.client.messages.create({
+          model: this.model,
+          max_tokens: 4e3,
+          temperature: 0.1,
+          messages: [{
+            role: "user",
+            content: prompt
+          }]
+        });
+        const content = response.content[0];
+        if (content.type !== "text") {
+          throw new Error("Unexpected response type from Anthropic API");
+        }
+        return this.parseResponse(content.text);
+      } catch (error) {
+        if (attempt === this.maxRetries) {
+          throw new Error(`Anthropic API failed after ${this.maxRetries} attempts: ${error}`);
+        }
+        console.warn(`Anthropic API attempt ${attempt} failed, retrying...`, error);
+        await this.delay(this.retryDelayMs * attempt);
+      }
+    }
+    throw new Error("Failed to generate template");
+  }
+  buildPrompt(request) {
+    return `You are an expert creating Mustache.js templates for **Voicenter - Leading Cloud Communications Platform**, converting Umbraco CMS content into LLMS.txt-optimized markdown.
+
+**BUSINESS CONTEXT**: Voicenter provides enterprise cloud telephony solutions including Contact Centers, Business Phone Services, Mobile Communications, API integrations, and AI-powered voice tools for 50,000+ users globally.
+
+**CURRENT PAGE ANALYSIS:**
+- URL: ${request.url}
+- Template: ${request.templateAlias}
+- JSONPath: ${request.jpath}
+
+**AVAILABLE DATA PROPERTIES:**
+\`\`\`json
+${JSON.stringify(request.pageContent, null, 2)}
+\`\`\`
+
+**CRITICAL REQUIREMENTS (2024 LLMS.txt Standard):**
+
+1. **USE EXACT PROPERTY NAMES**:
+   \u274C Wrong: {{pageTitle}}
+   \u2705 Correct: {{pageTittle}} or {{pageDescription}} (match actual JSON keys)
+
+2. **BUSINESS-FOCUSED CONTENT HIERARCHY**:
+   - H1: Clear service/feature name
+   - Blockquote: Value proposition
+   - H2: Key capabilities/benefits
+   - H3: Technical details/specs
+   - Lists: Features, integrations, use cases
+
+3. **VOICENTER-SPECIFIC CONTENT MAPPING**:
+   - Service descriptions \u2192 Clear business benefits
+   - Technical features \u2192 User-friendly explanations
+   - Integration lists \u2192 Specific partner names
+   - API documentation \u2192 Implementation clarity
+   - Contact info \u2192 Business value context
+
+4. **SMART CONTENT SELECTION**:
+   - Prioritize business value over technical jargon
+   - Include specific numbers/metrics when available
+   - Map complex nested arrays to structured lists
+   - Extract key differentiators and benefits
+
+**TEMPLATE PATTERNS FOR VOICENTER CONTENT:**
+
+**Service Pages Pattern:**
+\`\`\`mustache
+# {{serviceName}}
+
+{{#serviceSubtitle}}
+> {{serviceSubtitle}}
+{{/serviceSubtitle}}
+
+{{#serviceDescription}}
+## Overview
+{{serviceDescription}}
+{{/serviceDescription}}
+
+{{#serviceTools.0}}
+## Key Features
+{{#serviceTools}}
+- {{textItem}}
+{{/serviceTools}}
+{{/serviceTools.0}}
+
+{{#serviceLink}}
+## Learn More
+[Explore {{serviceName}} \u2192]({{serviceLink}})
+{{/serviceLink}}
+\`\`\`
+
+**Feature/API Pages Pattern:**
+\`\`\`mustache
+# {{cardTitle}}
+
+{{#cardText}}
+> {{cardText}}
+{{/cardText}}
+
+{{#featureDescription}}
+## How It Works
+{{featureDescription}}
+{{/featureDescription}}
+
+{{#capabilities.0}}
+## Capabilities
+{{#capabilities}}
+### {{name}}
+{{description}}
+
+{{/capabilities}}
+{{/capabilities.0}}
+
+## Business Benefits
+- Reduces operational costs
+- Improves customer experience
+- Seamless integration with existing systems
+\`\`\`
+
+**CONTENT EXTRACTION RULES:**
+1. **Identify primary content** from JSON structure
+2. **Map nested arrays** to organized sections
+3. **Extract business value** from technical descriptions
+4. **Include contact/action items** for lead generation
+5. **Maintain SEO-friendly** heading structure
+
+**OUTPUT REQUIREMENTS:**
+- Return ONLY the Mustache template
+- NO explanations or code blocks
+- Use actual property names from the provided JSON
+- Focus on business value for AI consumption
+- Follow LLMS.txt hierarchical structure
+- **CLEAN MARKDOWN ONLY**: No HTML tags, entities, or attributes
+- **NO HTML**: Use pure Markdown syntax (##, **, -, etc.)
+- **NO ENTITIES**: Use actual characters, not &amp; or &#x2F;
+- **NO ATTRIBUTES**: No dir="RTL", style="", class="" etc.
+
+Generate the optimized Mustache template:`;
+  }
+  parseResponse(responseText) {
+    const codeBlockRegex = /```(?:mustache)?\n?([\s\S]*?)```/;
+    const match = responseText.match(codeBlockRegex);
+    let template;
+    if (match) {
+      template = match[1].trim();
+    } else {
+      template = responseText.trim();
+    }
+    const metadata = this.extractMetadata(responseText);
+    return {
+      template,
+      metadata
+    };
+  }
+  extractMetadata(responseText) {
+    const titleMatch = responseText.match(/^#\s+(.+)$/m);
+    const descriptionMatch = responseText.match(/>\s*(.+)$/m);
+    return {
+      title: titleMatch ? titleMatch[1] : void 0,
+      description: descriptionMatch ? descriptionMatch[1] : void 0,
+      tags: []
+    };
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async testConnection() {
+    try {
+      const response = await this.client.messages.create({
+        model: this.model,
+        max_tokens: 10,
+        messages: [{
+          role: "user",
+          content: "Hello"
+        }]
+      });
+      return response.content.length > 0;
+    } catch (error) {
+      console.error("Anthropic API connection test failed:", error);
+      return false;
+    }
+  }
+}
+
+class PromptAnalyzer {
+  analyzeContent(pageContent, urlItem) {
+    const analysis = {
+      contentType: this.determineContentType(pageContent, urlItem),
+      hasImages: this.detectImages(pageContent),
+      hasHtml: this.detectHtml(pageContent),
+      hasLists: this.detectLists(pageContent),
+      hasNestedContent: this.detectNestedContent(pageContent),
+      keyProperties: this.identifyKeyProperties(pageContent),
+      suggestedHeaders: this.suggestHeaders(pageContent, urlItem),
+      complexityScore: 0
+    };
+    analysis.complexityScore = this.calculateComplexity(analysis, pageContent);
+    return analysis;
+  }
+  determineContentType(pageContent, urlItem) {
+    const { url, TemplateAlias } = urlItem;
+    const alias = (TemplateAlias || "unknown").toLowerCase();
+    if (url === "/" || alias.includes("home") || alias.includes("index")) {
+      return "homepage";
+    }
+    if (alias.includes("blog") || alias.includes("article") || alias.includes("news")) {
+      return "article";
+    }
+    if (alias.includes("list") || alias.includes("collection") || alias.includes("category") || alias.includes("archive")) {
+      return "listing";
+    }
+    if (alias.includes("detail") || alias.includes("product") || alias.includes("service") || alias.includes("camp")) {
+      return "detail";
+    }
+    if (alias.includes("form") || alias.includes("contact") || alias.includes("register") || this.hasFormFields(pageContent)) {
+      return "form";
+    }
+    if (alias.includes("about") || alias.includes("privacy") || alias.includes("terms") || alias.includes("static")) {
+      return "static";
+    }
+    return "unknown";
+  }
+  detectImages(content) {
+    const imageKeys = ["image", "img", "photo", "picture", "banner", "logo", "icon"];
+    return this.hasKeysContaining(content, imageKeys);
+  }
+  detectHtml(content) {
+    const htmlRegex = /<[^>]+>/;
+    return this.hasValuesMatching(content, htmlRegex);
+  }
+  detectLists(content) {
+    const listKeys = ["list", "items", "array", "collection", "features", "services"];
+    return this.hasKeysContaining(content, listKeys) || this.hasArrayValues(content);
+  }
+  detectNestedContent(content) {
+    return Object.values(content).some(
+      (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length >= 2
+    );
+  }
+  identifyKeyProperties(content) {
+    const priorityKeys = [
+      "pageTitle",
+      "title",
+      "name",
+      "heading",
+      "pageDescription",
+      "description",
+      "summary",
+      "intro",
+      "content",
+      "body",
+      "text",
+      "mainContent",
+      "url",
+      "link",
+      "action"
+    ];
+    const foundKeys = [];
+    const allKeys = this.getAllKeys(content);
+    for (const key of allKeys) {
+      const lowerKey = key.toLowerCase();
+      if (priorityKeys.some((priority) => lowerKey.includes(priority))) {
+        foundKeys.push(key);
+      }
+    }
+    return foundKeys.length > 0 ? foundKeys : allKeys.slice(0, 8);
+  }
+  suggestHeaders(content, urlItem) {
+    const headers = [];
+    headers.push("# {{pageTitle}}");
+    if (this.hasKeysContaining(content, ["description", "summary", "intro"])) {
+      headers.push("## Overview");
+    }
+    if (this.hasKeysContaining(content, ["feature", "service", "benefit"])) {
+      headers.push("## Features");
+    }
+    if (this.hasKeysContaining(content, ["detail", "information", "about"])) {
+      headers.push("## Details");
+    }
+    if (this.hasKeysContaining(content, ["contact", "form", "action"])) {
+      headers.push("## Contact Information");
+    }
+    return headers;
+  }
+  calculateComplexity(analysis, content) {
+    let score = 0;
+    score += Object.keys(content).length;
+    score += analysis.hasImages ? 10 : 0;
+    score += analysis.hasHtml ? 15 : 0;
+    score += analysis.hasLists ? 10 : 0;
+    score += analysis.hasNestedContent ? 20 : 0;
+    if (analysis.contentType === "homepage")
+      score += 25;
+    if (analysis.contentType === "listing")
+      score += 15;
+    return Math.min(score, 100);
+  }
+  hasFormFields(content) {
+    const formKeys = ["input", "button", "form", "field", "submit", "action"];
+    return this.hasKeysContaining(content, formKeys);
+  }
+  hasKeysContaining(obj, searchKeys) {
+    const allKeys = this.getAllKeys(obj).map((key) => key.toLowerCase());
+    return searchKeys.some(
+      (searchKey) => allKeys.some((key) => key.includes(searchKey))
+    );
+  }
+  hasValuesMatching(obj, regex) {
+    const allValues = this.getAllValues(obj);
+    return allValues.some(
+      (value) => typeof value === "string" && regex.test(value)
+    );
+  }
+  hasArrayValues(obj) {
+    return Object.values(obj).some((value) => Array.isArray(value));
+  }
+  getAllKeys(obj, prefix = "") {
+    let keys = [];
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      keys.push(fullKey);
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        keys = keys.concat(this.getAllKeys(value, fullKey));
+      }
+    }
+    return keys;
+  }
+  getAllValues(obj) {
+    let values = [];
+    for (const value of Object.values(obj)) {
+      values.push(value);
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        values = values.concat(this.getAllValues(value));
+      }
+    }
+    return values;
+  }
+}
+
+class LLMSCache {
+  cacheFilePath;
+  cache = {};
+  constructor(cacheDir) {
+    if (!existsSync(cacheDir)) {
+      mkdirSync(cacheDir, { recursive: true });
+    }
+    this.cacheFilePath = join(cacheDir, "templates.json");
+    this.loadCache();
+  }
+  loadCache() {
+    try {
+      if (existsSync(this.cacheFilePath)) {
+        const cacheContent = readFileSync(this.cacheFilePath, "utf-8");
+        this.cache = JSON.parse(cacheContent);
+      }
+    } catch (error) {
+      console.warn("Failed to load template cache:", error);
+      this.cache = {};
+    }
+  }
+  saveCache() {
+    try {
+      const cacheDir = dirname(this.cacheFilePath);
+      if (!existsSync(cacheDir)) {
+        mkdirSync(cacheDir, { recursive: true });
+      }
+      writeFileSync(this.cacheFilePath, JSON.stringify(this.cache, null, 2));
+    } catch (error) {
+      console.error("Failed to save template cache:", error);
+    }
+  }
+  hasTemplate(pageId) {
+    return pageId in this.cache;
+  }
+  getTemplate(pageId) {
+    const cached = this.cache[pageId];
+    if (!cached)
+      return null;
+    return {
+      pageId,
+      templatePath: "",
+      template: cached.template,
+      hash: cached.hash,
+      metadata: {
+        url: cached.metadata.pageId,
+        // Contains the URL from setTemplate
+        templateAlias: cached.metadata.templateAlias,
+        jpath: cached.metadata.jpath,
+        generatedAt: new Date(cached.metadata.lastUpdated)
+      }
+    };
+  }
+  getTemplateHash(pageId) {
+    return this.cache[pageId]?.hash || null;
+  }
+  setTemplate(pageId, template, hash, metadata) {
+    this.cache[pageId] = {
+      hash,
+      template,
+      metadata: {
+        ...metadata,
+        lastUpdated: /* @__PURE__ */ new Date()
+      }
+    };
+    this.saveCache();
+  }
+  removeTemplate(pageId) {
+    delete this.cache[pageId];
+    this.saveCache();
+  }
+  clearCache() {
+    this.cache = {};
+    this.saveCache();
+  }
+  getCacheStats() {
+    const templates = Object.values(this.cache);
+    const templatesByAlias = {};
+    let oldestTemplate = null;
+    let newestTemplate = null;
+    for (const template of templates) {
+      const alias = template.metadata.templateAlias;
+      templatesByAlias[alias] = (templatesByAlias[alias] || 0) + 1;
+      const date = new Date(template.metadata.lastUpdated);
+      if (!oldestTemplate || date < oldestTemplate) {
+        oldestTemplate = date;
+      }
+      if (!newestTemplate || date > newestTemplate) {
+        newestTemplate = date;
+      }
+    }
+    return {
+      totalTemplates: templates.length,
+      templatesByAlias,
+      oldestTemplate,
+      newestTemplate
+    };
+  }
+  cleanupOldTemplates(maxAgeMs) {
+    const cutoffDate = new Date(Date.now() - maxAgeMs);
+    let removedCount = 0;
+    for (const [pageId, template] of Object.entries(this.cache)) {
+      const templateDate = new Date(template.metadata.lastUpdated);
+      if (templateDate < cutoffDate) {
+        delete this.cache[pageId];
+        removedCount++;
+      }
+    }
+    if (removedCount > 0) {
+      this.saveCache();
+    }
+    return removedCount;
+  }
+  getAllTemplates() {
+    return { ...this.cache };
+  }
+}
+
+function generatePageStructureHash(pageData, options = {}) {
+  const {
+    excludeChildren = true,
+    excludeKeys = [],
+    includeOnlyKeys = []
+  } = options;
+  const processedData = processPageDataForHash(pageData, {
+    excludeChildren,
+    excludeKeys,
+    includeOnlyKeys
+  });
+  const sortedKeys = Object.keys(processedData).sort();
+  const hashInput = sortedKeys.join("|");
+  return createHash("sha256").update(hashInput).digest("hex");
+}
+function processPageDataForHash(data, options) {
+  const { excludeChildren, excludeKeys = [], includeOnlyKeys = [] } = options;
+  const processed = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (excludeChildren && key === "children") {
+      continue;
+    }
+    if (excludeKeys.includes(key)) {
+      continue;
+    }
+    if (includeOnlyKeys.length > 0 && !includeOnlyKeys.includes(key)) {
+      continue;
+    }
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      processed[key] = processPageDataForHash(value, options);
+    } else {
+      processed[key] = getValueType(value);
+    }
+  }
+  return processed;
+}
+function getValueType(value) {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return `array[${value.length}]`;
+  if (typeof value === "object")
+    return "object";
+  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) {
+  return `${urlItem.TemplateAlias}_${urlItem.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);
+    if (!pageContent) {
+      console.warn(`No content found for ${urlItem.url}, skipping template generation`);
+      return false;
+    }
+    const hidePage = pageContent.hidePage;
+    if (hidePage === "1" || hidePage === 1) {
+      console.log(`Page ${urlItem.url} is hidden (hidePage: ${hidePage}), skipping template generation`);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error(`Error checking visibility for ${urlItem.url}:`, error);
+    return false;
+  }
+}
+function getVisiblePages(umbracoData) {
+  return umbracoData.urlList.filter(
+    (urlItem) => shouldGenerateTemplate(umbracoData, urlItem)
+  );
+}
+function getPageVisibilityStats(umbracoData) {
+  let visible = 0;
+  let hidden = 0;
+  let error = 0;
+  for (const urlItem of umbracoData.urlList) {
+    try {
+      const pageContent = extractPageContent(umbracoData, urlItem.Jpath);
+      if (!pageContent) {
+        error++;
+        continue;
+      }
+      const hidePage = pageContent.hidePage;
+      if (hidePage === "1" || hidePage === 1) {
+        hidden++;
+      } else {
+        visible++;
+      }
+    } catch {
+      error++;
+    }
+  }
+  return {
+    total: umbracoData.urlList.length,
+    visible,
+    hidden,
+    error
+  };
+}
+
+class TemplateCleanup {
+  cache;
+  constructor(cacheDir) {
+    this.cache = new LLMSCache(cacheDir);
+  }
+  /**
+  * Find templates that no longer have corresponding pages
+  */
+  findOrphanedTemplates(umbracoData) {
+    const orphanedTemplates = [];
+    const cacheStats = this.cache.getCacheStats();
+    console.log(`\u{1F50D} Checking ${cacheStats.totalTemplates} cached templates for orphans...`);
+    const currentPageIds = /* @__PURE__ */ new Set();
+    for (const urlItem of umbracoData.urlList) {
+      try {
+        const pageId = generatePageId(urlItem);
+        currentPageIds.add(pageId);
+      } catch (error) {
+        console.warn(`Error generating page ID for ${urlItem.url}:`, error);
+      }
+    }
+    const allCachedTemplates = this.cache.getAllTemplates();
+    for (const [pageId, templateData] of Object.entries(allCachedTemplates)) {
+      if (!currentPageIds.has(pageId)) {
+        orphanedTemplates.push({
+          pageId,
+          templateAlias: templateData.metadata.templateAlias,
+          lastUpdated: new Date(templateData.metadata.lastUpdated),
+          url: templateData.metadata.pageId,
+          // URL stored in pageId field from cache
+          reason: "page_deleted"
+        });
+      }
+    }
+    return orphanedTemplates;
+  }
+  /**
+  * Find templates for pages that are now hidden (hidePage: "1")
+  */
+  findHiddenPageTemplates(umbracoData) {
+    const hiddenTemplates = [];
+    const allCachedTemplates = this.cache.getAllTemplates();
+    for (const urlItem of umbracoData.urlList) {
+      try {
+        const pageId = generatePageId(urlItem);
+        const templateData = allCachedTemplates[pageId];
+        if (templateData) {
+          const pageContent = extractPageContent(umbracoData, urlItem.Jpath);
+          if (pageContent?.hidePage === "1" || pageContent?.hidePage === 1) {
+            hiddenTemplates.push({
+              pageId,
+              templateAlias: templateData.metadata.templateAlias,
+              lastUpdated: new Date(templateData.metadata.lastUpdated),
+              url: urlItem.url,
+              reason: "page_hidden"
+            });
+          }
+        }
+      } catch (error) {
+        console.warn(`Error checking hidden status for ${urlItem.url}:`, error);
+      }
+    }
+    return hiddenTemplates;
+  }
+  /**
+  * Perform cleanup of orphaned templates
+  */
+  performCleanup(umbracoData, options = {}) {
+    const {
+      removeOrphaned = true,
+      removeHidden = true,
+      dryRun = false
+    } = options;
+    const initialStats = this.cache.getCacheStats();
+    const orphanedTemplates = [];
+    let templatesRemoved = 0;
+    if (removeOrphaned) {
+      const orphaned = this.findOrphanedTemplates(umbracoData);
+      orphanedTemplates.push(...orphaned);
+    }
+    if (removeHidden) {
+      const hidden = this.findHiddenPageTemplates(umbracoData);
+      orphanedTemplates.push(...hidden);
+    }
+    console.log(`\u{1F5D1}\uFE0F  Found ${orphanedTemplates.length} orphaned templates`);
+    if (orphanedTemplates.length > 0) {
+      orphanedTemplates.forEach((template) => {
+        console.log(`  - ${template.pageId} (${template.reason}): ${template.templateAlias} - ${template.url}`);
+      });
+      if (!dryRun) {
+        orphanedTemplates.forEach((template) => {
+          this.cache.removeTemplate(template.pageId);
+          templatesRemoved++;
+        });
+        console.log(`\u2705 Removed ${templatesRemoved} orphaned templates`);
+      } else {
+        console.log(`\u{1F50D} DRY RUN: Would remove ${orphanedTemplates.length} templates`);
+      }
+    }
+    return {
+      totalTemplatesBeforeCleanup: initialStats.totalTemplates,
+      orphanedTemplatesFound: orphanedTemplates.length,
+      templatesRemoved,
+      orphanedTemplates
+    };
+  }
+  /**
+  * Get cleanup recommendations without performing cleanup
+  */
+  getCleanupRecommendations(umbracoData) {
+    const orphaned = this.findOrphanedTemplates(umbracoData);
+    const hidden = this.findHiddenPageTemplates(umbracoData);
+    const totalOrphaned = orphaned.length + hidden.length;
+    const recommendations = [];
+    if (orphaned.length > 0) {
+      recommendations.push(`${orphaned.length} templates for deleted pages should be removed`);
+    }
+    if (hidden.length > 0) {
+      recommendations.push(`${hidden.length} templates for hidden pages should be removed`);
+    }
+    if (totalOrphaned === 0) {
+      recommendations.push("No cleanup needed - all templates are current");
+    }
+    return {
+      shouldCleanup: totalOrphaned > 0,
+      orphanedCount: totalOrphaned,
+      recommendations
+    };
+  }
+  /**
+  * Extract page content using JSONPath (simplified version)
+  */
+  extractPageContent(umbracoData, jpath) {
+    try {
+      const pathParts = jpath.split(".");
+      let current = umbracoData;
+      for (const part of pathParts) {
+        if (part === "$")
+          continue;
+        if (current && typeof current === "object" && part in current) {
+          current = current[part];
+        } else {
+          return null;
+        }
+      }
+      return current;
+    } catch (error) {
+      console.warn(`Error extracting content for ${jpath}:`, error);
+      return null;
+    }
+  }
+}
+async function performAutomaticCleanup(umbracoData, cacheDir, options = {}) {
+  const {
+    enableAutoCleanup = true,
+    cleanupOrphaned = true,
+    cleanupHidden = true,
+    dryRun = false
+  } = options;
+  if (!enableAutoCleanup) {
+    return null;
+  }
+  const cleanup = new TemplateCleanup(cacheDir);
+  console.log("\u{1F9F9} Performing automatic template cleanup...");
+  const stats = cleanup.performCleanup(umbracoData, {
+    removeOrphaned: cleanupOrphaned,
+    removeHidden: cleanupHidden,
+    dryRun
+  });
+  if (stats.templatesRemoved > 0) {
+    console.log(`\u2705 Cleaned up ${stats.templatesRemoved} orphaned templates`);
+  }
+  return stats;
+}
+
+class MustacheSyntaxValidator {
+  name = "mustache-syntax";
+  canFix = true;
+  validate(template) {
+    const result = {
+      isValid: true,
+      errors: [],
+      warnings: []
+    };
+    try {
+      Mustache.parse(template);
+      return result;
+    } catch (error) {
+      result.isValid = false;
+      result.errors.push(`Mustache syntax error: ${error.message}`);
+      if (this.canFix) {
+        try {
+          const fixedTemplate = this.fix(template);
+          result.fixedTemplate = fixedTemplate;
+          result.warnings.push("Template was automatically fixed");
+        } catch (fixError) {
+          result.errors.push(`Could not fix template: ${fixError.message}`);
+        }
+      }
+      return result;
+    }
+  }
+  fix(template) {
+    let fixedTemplate = template;
+    const openSectionRegex = /\{\{\#([a-zA-Z0-9_.]+)\}\}/g;
+    const closeSectionRegex = /\{\{\/([a-zA-Z0-9_.]+)\}\}/g;
+    const openSections = [];
+    const closeSections = [];
+    let match;
+    while ((match = openSectionRegex.exec(template)) !== null) {
+      openSections.push({
+        name: match[1],
+        pos: match.index
+      });
+    }
+    while ((match = closeSectionRegex.exec(template)) !== null) {
+      closeSections.push({
+        name: match[1],
+        pos: match.index
+      });
+    }
+    const unmatchedOpens = openSections.filter(
+      (open) => !closeSections.some((close) => close.name === open.name)
+    );
+    const unmatchedCloses = closeSections.filter(
+      (close) => !openSections.some((open) => open.name === close.name)
+    );
+    unmatchedOpens.forEach((unmatched) => {
+      const sectionRegex = new RegExp(`\\{\\{#${unmatched.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\}\\}`, "g");
+      fixedTemplate = fixedTemplate.replace(sectionRegex, "");
+    });
+    unmatchedCloses.forEach((unmatched) => {
+      const sectionRegex = new RegExp(`\\{\\{/${unmatched.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\}\\}`, "g");
+      fixedTemplate = fixedTemplate.replace(sectionRegex, "");
+    });
+    fixedTemplate = fixedTemplate.replace(/\n\s*\n\s*\n/g, "\n\n");
+    return fixedTemplate;
+  }
+}
+class TemplateStructureValidator {
+  name = "template-structure";
+  validate(template) {
+    const result = {
+      isValid: true,
+      errors: [],
+      warnings: []
+    };
+    if (!template.match(/^#\s+/m)) {
+      result.warnings.push("Template should start with a heading (# Title)");
+    }
+    const headingLevels = (template.match(/^#{4,}/gm) || []).length;
+    if (headingLevels > 0) {
+      result.warnings.push("Template has deeply nested headings (4+ levels), consider flattening structure");
+    }
+    const emptySections = template.match(/\{\{#\w+\}\}\s*\{\{\/\w+\}\}/g);
+    if (emptySections) {
+      result.warnings.push(`Found ${emptySections.length} empty sections that may not render content`);
+    }
+    const commonTypos = template.match(/\{\{\s*pageTittle\s*\}\}/g);
+    if (commonTypos) {
+      result.warnings.push('Found "pageTittle" - check if this should be "pageTitle"');
+    }
+    return result;
+  }
+}
+class ContentCompletenessValidator {
+  name = "content-completeness";
+  validate(template) {
+    const result = {
+      isValid: true,
+      errors: [],
+      warnings: []
+    };
+    const variables = this.extractVariables(template);
+    const hasTitle = variables.some((v) => v.includes("title") || v.includes("Title"));
+    if (!hasTitle) {
+      result.warnings.push("Template missing title variable (pageTitle, title, etc.)");
+    }
+    const hasDescription = variables.some((v) => v.includes("description") || v.includes("Description"));
+    if (!hasDescription) {
+      result.warnings.push("Template missing description variable");
+    }
+    if (template.length < 50) {
+      result.warnings.push("Template is very short, may not provide sufficient content");
+    }
+    const sectionsOnly = variables.filter((v) => !v.includes(".") && !v.includes("["));
+    if (sectionsOnly.length < 2) {
+      result.warnings.push("Template has limited content variables, consider adding more sections");
+    }
+    return result;
+  }
+  extractVariables(template) {
+    const variableRegex = /\{\{\s*([^#\/][^}]*?)\s*\}\}/g;
+    const variables = [];
+    let match;
+    while ((match = variableRegex.exec(template)) !== null) {
+      variables.push(match[1].trim());
+    }
+    return variables;
+  }
+}
+class LLMSTxtComplianceValidator {
+  name = "llms-txt-compliance";
+  validate(template) {
+    const result = {
+      isValid: true,
+      errors: [],
+      warnings: []
+    };
+    const headings = template.match(/^#+\s+.+$/gm) || [];
+    let lastLevel = 0;
+    let hasProperHierarchy = true;
+    headings.forEach((heading) => {
+      const level = (heading.match(/^#+/) || [""])[0].length;
+      if (level > lastLevel + 1) {
+        hasProperHierarchy = false;
+      }
+      lastLevel = level;
+    });
+    if (!hasProperHierarchy) {
+      result.warnings.push("Heading hierarchy should increment by one level (# -> ## -> ###)");
+    }
+    if (template.includes("pageDescription") && !template.includes(">")) {
+      result.warnings.push("Consider using blockquote (>) for page description as per LLMS.txt standard");
+    }
+    const hasLists = template.includes("- ") || template.includes("* ");
+    if (!hasLists && template.length > 200) {
+      result.warnings.push("Long content without lists - consider breaking into bullet points for better AI consumption");
+    }
+    const htmlTags = (template.match(/<[^>]+>/g) || []).length;
+    if (htmlTags > 3) {
+      result.warnings.push("Template contains HTML tags - prefer pure markdown for LLMS.txt compliance");
+    }
+    return result;
+  }
+}
+class TemplateValidationPipeline {
+  validators = [];
+  constructor() {
+    this.addValidator(new MustacheSyntaxValidator());
+    this.addValidator(new TemplateStructureValidator());
+    this.addValidator(new ContentCompletenessValidator());
+    this.addValidator(new LLMSTxtComplianceValidator());
+  }
+  addValidator(validator) {
+    this.validators.push(validator);
+  }
+  removeValidator(name) {
+    this.validators = this.validators.filter((v) => v.name !== name);
+  }
+  async validateTemplate(template, options = {}) {
+    const { autoFix = true, throwOnError = false } = options;
+    let currentTemplate = template;
+    const allResults = {
+      isValid: true,
+      errors: [],
+      warnings: []
+    };
+    for (const validator of this.validators) {
+      const result = validator.validate(currentTemplate);
+      allResults.errors.push(...result.errors);
+      allResults.warnings.push(...result.warnings);
+      if (!result.isValid) {
+        allResults.isValid = false;
+        if (autoFix && validator.canFix && validator.fix) {
+          const fixedTemplate = validator.fix(currentTemplate);
+          const fixResult = validator.validate(fixedTemplate);
+          if (fixResult.isValid) {
+            currentTemplate = fixedTemplate;
+            allResults.fixedTemplate = currentTemplate;
+            console.log(`Template fixed by ${validator.name} validator`);
+            allResults.errors = allResults.errors.filter((e) => !result.errors.includes(e));
+            if (allResults.errors.length === 0) {
+              allResults.isValid = true;
+            }
+          }
+        }
+      }
+    }
+    if (allResults.errors.length > 0 && throwOnError) {
+      throw new TemplateError(
+        ErrorCode.TEMPLATE_VALIDATION_FAILED,
+        `Template validation failed: ${allResults.errors.join(", ")}`,
+        { template: template.substring(0, 200) + "..." }
+      );
+    }
+    return allResults;
+  }
+  async validateAndFix(template) {
+    const result = await this.validateTemplate(template, {
+      autoFix: true,
+      throwOnError: false
+    });
+    if (result.fixedTemplate) {
+      return result.fixedTemplate;
+    }
+    if (result.errors.length > 0) {
+      console.warn("Could not fix template, using fallback");
+      return `# {{pageTitle}}
+
+> {{pageDescription}}
+
+## Content
+
+This page content could not be processed due to template formatting issues.`;
+    }
+    return template;
+  }
+  getValidatorNames() {
+    return this.validators.map((v) => v.name);
+  }
+}
+const templateValidationPipeline = new TemplateValidationPipeline();
+
+class TemplateGenerator {
+  anthropicClient;
+  promptAnalyzer;
+  cache;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.anthropicClient = new AnthropicClient(config);
+    this.promptAnalyzer = new PromptAnalyzer();
+    if (config.cacheDir) {
+      this.cache = new LLMSCache(config.cacheDir);
+    } else {
+      this.cache = new LLMSCache(".llms-cache");
+    }
+    this.ensureOutputDirectories();
+  }
+  async generateTemplate(pageContent, urlItem) {
+    const pageId = generatePageId(urlItem);
+    const currentHash = generatePageStructureHash(pageContent, { excludeChildren: true });
+    const cachedHash = this.cache.getTemplateHash(pageId);
+    if (cachedHash === currentHash) {
+      console.log(`Using cached template for ${pageId}`);
+      const cached = this.cache.getTemplate(pageId);
+      if (cached) {
+        return cached;
+      }
+    }
+    return await this.generateTemplateWithAI(pageContent, urlItem);
+  }
+  async generateAllTemplates(umbracoData) {
+    const templates = [];
+    const maxConcurrent = this.config.maxConcurrent || 5;
+    await performAutomaticCleanup(umbracoData, this.config.cacheDir || "./cache", {
+      enableAutoCleanup: this.config.enableAutoCleanup ?? true,
+      cleanupOrphaned: this.config.cleanupOrphaned ?? true,
+      cleanupHidden: this.config.cleanupHidden ?? true,
+      dryRun: false
+    });
+    const visibilityStats = getPageVisibilityStats(umbracoData);
+    console.log("\u{1F4CA} Page visibility stats:", visibilityStats);
+    const visiblePages = umbracoData.urlList.filter(
+      (urlItem) => shouldGenerateTemplate(umbracoData, urlItem)
+    );
+    console.log(`Checking ${visiblePages.length}/${umbracoData.urlList.length} visible pages for cache status...`);
+    const { cached, needGeneration } = this.identifyTemplatesNeeded(umbracoData, visiblePages);
+    console.log(`\u{1F4C8} Template status: ${cached.length} cached, ${needGeneration.length} need generation`);
+    templates.push(...cached);
+    if (needGeneration.length === 0) {
+      console.log("All templates are cached, no AI generation needed");
+      return templates;
+    }
+    console.log(`Generating ${needGeneration.length} missing templates (max ${maxConcurrent} concurrent)`);
+    for (let i = 0; i < needGeneration.length; i += maxConcurrent) {
+      const batch = needGeneration.slice(i, i + maxConcurrent);
+      const batchPromises = batch.map(async ({ pageContent, urlItem }) => {
+        try {
+          return await this.generateTemplateWithAI(pageContent, urlItem);
+        } catch (error) {
+          console.error(`Error processing ${urlItem.url}:`, error);
+          return null;
+        }
+      });
+      const batchResults = await Promise.all(batchPromises);
+      const validResults = batchResults.filter((result) => result !== null);
+      templates.push(...validResults);
+      if (i + maxConcurrent < needGeneration.length) {
+        console.log(`Completed batch ${Math.floor(i / maxConcurrent) + 1}, waiting 1s...`);
+        await this.delay(1e3);
+      }
+    }
+    console.log(`Generated ${templates.length} total templates (${cached.length} from cache, ${templates.length - cached.length} newly generated)`);
+    return templates;
+  }
+  identifyTemplatesNeeded(umbracoData, visiblePages) {
+    const cached = [];
+    const needGeneration = [];
+    for (const urlItem of visiblePages) {
+      const pageContent = extractPageContent(umbracoData, urlItem.Jpath);
+      if (!pageContent) {
+        console.warn(`No content found for ${urlItem.url} (${urlItem.Jpath})`);
+        continue;
+      }
+      const pageId = generatePageId(urlItem);
+      const currentHash = generatePageStructureHash(pageContent, { excludeChildren: true });
+      const cachedHash = this.cache.getTemplateHash(pageId);
+      if (cachedHash === currentHash) {
+        const cachedTemplate = this.cache.getTemplate(pageId);
+        if (cachedTemplate) {
+          cached.push(cachedTemplate);
+          continue;
+        }
+      }
+      needGeneration.push({
+        pageContent,
+        urlItem
+      });
+    }
+    return {
+      cached,
+      needGeneration
+    };
+  }
+  async generateTemplateWithAI(pageContent, urlItem) {
+    const pageId = generatePageId(urlItem);
+    console.log(`Generating new template for ${pageId} (${urlItem.url})`);
+    const tokensBeforeTruncation = estimateContentTokens(pageContent);
+    const truncatedContent = truncateContentIfNeeded(pageContent, 18e4);
+    const tokensAfterTruncation = estimateContentTokens(truncatedContent);
+    if (tokensBeforeTruncation > tokensAfterTruncation) {
+      console.warn(`Page ${pageId} content truncated: ${tokensBeforeTruncation} -> ${tokensAfterTruncation} tokens`);
+    }
+    this.promptAnalyzer.analyzeContent(truncatedContent, urlItem);
+    const request = {
+      pageContent: truncatedContent,
+      templateAlias: urlItem.TemplateAlias,
+      url: urlItem.url,
+      jpath: urlItem.Jpath
+    };
+    const response = await this.anthropicClient.generateTemplate(request);
+    const currentHash = generatePageStructureHash(pageContent, { excludeChildren: true });
+    const templatePath = join(
+      this.config.templatesOutputDir,
+      `${pageId}.mustache`
+    );
+    this.saveTemplate(templatePath, response.template);
+    const generatedTemplate = {
+      pageId,
+      templatePath,
+      template: response.template,
+      hash: currentHash,
+      metadata: {
+        url: urlItem.url,
+        templateAlias: urlItem.TemplateAlias,
+        jpath: urlItem.Jpath,
+        generatedAt: /* @__PURE__ */ new Date()
+      }
+    };
+    this.cache.setTemplate(pageId, response.template, currentHash, {
+      pageId: urlItem.url,
+      // Store URL as pageId for cache lookup
+      jpath: urlItem.Jpath,
+      templateAlias: urlItem.TemplateAlias,
+      structureHash: currentHash
+    });
+    return generatedTemplate;
+  }
+  async renderTemplate(template, data) {
+    return withErrorHandling(async () => {
+      const validatedTemplate = await templateValidationPipeline.validateAndFix(template);
+      return Mustache.render(validatedTemplate, data);
+    }, {
+      template: template.substring(0, 200) + "...",
+      dataKeys: Object.keys(data)
+    });
+  }
+  loadTemplate(templatePath) {
+    try {
+      return readFileSync(templatePath, "utf-8");
+    } catch (error) {
+      throw new Error(`Failed to load template ${templatePath}: ${error}`);
+    }
+  }
+  getTemplateStats() {
+    const stats = this.cache.getCacheStats();
+    return {
+      totalCached: stats.totalTemplates,
+      cacheHitRate: stats.totalTemplates > 0 ? 0.8 : 0,
+      // Estimate, could be tracked more precisely
+      templatesByAlias: stats.templatesByAlias
+    };
+  }
+  saveTemplate(templatePath, content) {
+    const dir = dirname(templatePath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(templatePath, content, "utf-8");
+  }
+  ensureOutputDirectories() {
+    if (!existsSync(this.config.templatesOutputDir)) {
+      mkdirSync(this.config.templatesOutputDir, { recursive: true });
+    }
+    if (this.config.finalOutputDir && !existsSync(this.config.finalOutputDir)) {
+      mkdirSync(this.config.finalOutputDir, { recursive: true });
+    }
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async testConnection() {
+    return await this.anthropicClient.testConnection();
+  }
+  clearCache() {
+    this.cache.clearCache();
+  }
+  cleanupOldTemplates(maxAgeMs = 30 * 24 * 60 * 60 * 1e3) {
+    return this.cache.cleanupOldTemplates(maxAgeMs);
+  }
+}
+
+class LLMSFilesGenerator {
+  config;
+  templateGenerator;
+  constructor(config) {
+    this.config = config;
+    this.templateGenerator = new TemplateGenerator(config);
+  }
+  async generateAllFiles(umbracoData) {
+    const startTime = Date.now();
+    console.log("\u{1F680} Starting LLMS files generation...");
+    const templates = await this.templateGenerator.generateAllTemplates(umbracoData);
+    console.log("\u{1F4C4} Generating individual markdown files...");
+    const individualMdFiles = this.config.enableIndividualMd ? await this.generateIndividualMarkdownFiles(umbracoData, templates) : void 0;
+    console.log("\u{1F4DD} Generating llms.txt navigation file...");
+    const llmsTxt = this.generateLLMSTxt(umbracoData, individualMdFiles || []);
+    console.log("\u{1F4DA} Generating llms-full.txt...");
+    const llmsFullTxt = this.config.enableLLMSFullTxt ? this.generateLLMSFullTxt(umbracoData, individualMdFiles || []) : void 0;
+    const files = {
+      llmsTxt,
+      llmsFullTxt,
+      individualMdFiles
+    };
+    this.saveFilesToOutput(files);
+    const duration = Date.now() - startTime;
+    console.log(`\u2705 LLMS files generation completed in ${duration}ms`);
+    return files;
+  }
+  async generateIndividualMarkdownFiles(umbracoData, templates) {
+    const mdFiles = [];
+    for (const template of templates) {
+      try {
+        const urlItem = umbracoData.urlList.find(
+          (item) => generatePageId(item) === template.pageId
+        );
+        if (!urlItem) {
+          console.warn(`URL item not found for template ${template.pageId}`);
+          continue;
+        }
+        const pageContent = extractPageContent(umbracoData, urlItem.Jpath);
+        if (!pageContent) {
+          console.warn(`Page content not found for ${urlItem.url}`);
+          continue;
+        }
+        const renderedMarkdown = await this.templateGenerator.renderTemplate(
+          template.template,
+          pageContent
+        );
+        const sanitizedUrl = this.sanitizeUrlForFilename(urlItem.url);
+        const filename = `${sanitizedUrl}.md`;
+        const outputPath = join(this.getOutputDir(), "llms", filename);
+        mdFiles.push({
+          path: outputPath,
+          content: renderedMarkdown,
+          url: urlItem.url,
+          pageId: template.pageId
+        });
+      } catch (error) {
+        console.error(`Error generating markdown for ${template.pageId}:`, error);
+      }
+    }
+    return mdFiles;
+  }
+  generateLLMSTxt(umbracoData, mdFiles) {
+    const siteTitle = this.extractSiteTitle(umbracoData);
+    const siteDescription = this.extractSiteDescription(umbracoData);
+    let content = `# ${siteTitle}
+
+`;
+    if (siteDescription) {
+      content += `> ${siteDescription}
+
+`;
+    }
+    content += `This website contains comprehensive information about ${siteTitle.toLowerCase()}. The content is organized into the following sections:
+
+`;
+    const pagesByCategory = this.groupPagesByCategory(umbracoData, mdFiles);
+    for (const [category, pages] of Object.entries(pagesByCategory)) {
+      if (pages.length === 0)
+        continue;
+      content += `## ${this.formatCategoryName(category)}
+
+`;
+      for (const page of pages) {
+        const urlItem = umbracoData.urlList.find((item) => item.url === page.url);
+        const pageTitle = this.extractPageTitle(umbracoData, urlItem);
+        const relativeFilePath = this.getLLMSFilePath(page.path);
+        content += `- [${pageTitle}](${relativeFilePath}): ${this.generatePageDescription(umbracoData, urlItem)}
+`;
+      }
+      content += "\n";
+    }
+    const visiblePages = getVisiblePages(umbracoData);
+    const hiddenCount = umbracoData.urlList.length - visiblePages.length;
+    if (hiddenCount > 0) {
+      content += `*Note: ${hiddenCount} pages are excluded from this documentation as they are marked as hidden.*
+
+`;
+    }
+    content += "## Optional\n\n";
+    content += "- [Complete Documentation](llms-full.txt): All content combined in a single file\n";
+    content += "- [Site Map](sitemap.xml): XML sitemap of all pages\n";
+    const outputPath = join(this.getOutputDir(), "llms.txt");
+    return {
+      path: outputPath,
+      content: content.trim()
+    };
+  }
+  generateLLMSFullTxt(umbracoData, mdFiles) {
+    const siteTitle = this.extractSiteTitle(umbracoData);
+    const siteDescription = this.extractSiteDescription(umbracoData);
+    let content = `# ${siteTitle} - Complete Documentation
+
+`;
+    if (siteDescription) {
+      content += `> ${siteDescription}
+
+`;
+    }
+    content += "This document contains all website content in a single file for comprehensive AI analysis.\n\n";
+    content += "---\n\n";
+    for (const mdFile of mdFiles) {
+      const urlItem = umbracoData.urlList.find((item) => item.url === mdFile.url);
+      if (!urlItem)
+        continue;
+      content += `## Page: ${mdFile.url}
+
+`;
+      content += `**Template**: ${urlItem.TemplateAlias}
+`;
+      content += `**Node ID**: ${urlItem.nodeID}
+
+`;
+      content += mdFile.content;
+      content += "\n\n---\n\n";
+    }
+    const outputPath = join(this.getOutputDir(), "llms-full.txt");
+    return {
+      path: outputPath,
+      content: content.trim()
+    };
+  }
+  saveFilesToOutput(files) {
+    const outputDir = this.getOutputDir();
+    mkdirSync(outputDir, { recursive: true });
+    mkdirSync(join(outputDir, "llms"), { recursive: true });
+    writeFileSync(files.llmsTxt.path, files.llmsTxt.content, "utf-8");
+    console.log(`\u{1F4C4} Saved: ${files.llmsTxt.path}`);
+    if (files.llmsFullTxt) {
+      writeFileSync(files.llmsFullTxt.path, files.llmsFullTxt.content, "utf-8");
+      console.log(`\u{1F4DA} Saved: ${files.llmsFullTxt.path}`);
+    }
+    if (files.individualMdFiles) {
+      for (const mdFile of files.individualMdFiles) {
+        writeFileSync(mdFile.path, mdFile.content, "utf-8");
+      }
+      console.log(`\u{1F4DD} Saved: ${files.individualMdFiles.length} markdown files to llms/ subdirectory`);
+    }
+  }
+  groupPagesByCategory(umbracoData, mdFiles) {
+    const categories = {
+      main: [],
+      blog: [],
+      services: [],
+      products: [],
+      info: [],
+      other: []
+    };
+    for (const mdFile of mdFiles) {
+      const urlItem = umbracoData.urlList.find((item) => item.url === mdFile.url);
+      if (!urlItem)
+        continue;
+      const category = this.categorizeUrlItem(urlItem);
+      if (!categories[category]) {
+        categories[category] = [];
+      }
+      categories[category].push(mdFile);
+    }
+    return categories;
+  }
+  categorizeUrlItem(urlItem) {
+    const { url, TemplateAlias } = urlItem;
+    const alias = (TemplateAlias || "unknown").toLowerCase();
+    url.toLowerCase();
+    if (url === "/" || alias.includes("home"))
+      return "main";
+    if (alias.includes("blog") || alias.includes("article") || alias.includes("news"))
+      return "blog";
+    if (alias.includes("service") || alias.includes("product") || alias.includes("camp"))
+      return "services";
+    if (alias.includes("about") || alias.includes("contact") || alias.includes("info"))
+      return "info";
+    return "other";
+  }
+  extractSiteTitle(umbracoData) {
+    const siteData = umbracoData.SiteData;
+    return siteData?.pageTitle || siteData?.mainHeaderBlockTitle || "Website Documentation";
+  }
+  extractSiteDescription(umbracoData) {
+    const siteData = umbracoData.SiteData;
+    return siteData?.pageDescription || siteData?.ogDescription || null;
+  }
+  extractPageTitle(umbracoData, urlItem) {
+    if (!urlItem)
+      return "Untitled Page";
+    const pageContent = extractPageContent(umbracoData, urlItem.Jpath);
+    if (!pageContent)
+      return urlItem.TemplateAlias;
+    return pageContent.pageTitle || pageContent.title || pageContent.headerBlockTitle || urlItem.TemplateAlias;
+  }
+  generatePageDescription(umbracoData, urlItem) {
+    if (!urlItem)
+      return "Page information";
+    const pageContent = extractPageContent(umbracoData, urlItem.Jpath);
+    if (!pageContent)
+      return `${urlItem.TemplateAlias} page`;
+    const desc = pageContent.pageDescription || pageContent.description || pageContent.headerBlockSubtitle;
+    if (desc && typeof desc === "string") {
+      return desc.length > 100 ? `${desc.substring(0, 97)}...` : desc;
+    }
+    return `Information about ${urlItem.url}`;
+  }
+  formatCategoryName(category) {
+    const names = {
+      main: "Main Pages",
+      blog: "Blog & Articles",
+      services: "Services & Products",
+      info: "Information Pages",
+      other: "Other Pages"
+    };
+    return names[category] || category.charAt(0).toUpperCase() + category.slice(1);
+  }
+  sanitizeUrlForFilename(url) {
+    return url.replace(/^\//, "").replace(/\/$/, "").replace(/\//g, "-").replace(/[^a-zA-Z0-9\-_]/g, "").replace(/^$/, "index");
+  }
+  getRelativeFilePath(fullPath) {
+    const filename = fullPath.split("/").pop() || "";
+    return filename;
+  }
+  getLLMSFilePath(fullPath) {
+    const filename = fullPath.split("/").pop() || "";
+    return `llms/${filename}`;
+  }
+  getOutputDir() {
+    return this.config.finalOutputDir || "dist";
+  }
+}
+
+export { LLMSFilesGenerator };