@voicenter-team/nuxt-llms-generator 0.1.6 → 0.1.8

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

@@ -4,11 +4,199 @@ 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.11eb2a36.mjs';
+import { w as withErrorHandling } from '../shared/nuxt-llms-generator.bc139143.mjs';
 import '@nuxt/kit';
 import 'zod';
 import 'node-html-markdown';
 
+function buildLLMSTemplatePrompt(request) {
+  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/).
+
+---
+
+## \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.
+
+**Primary Goal:** Enable LLMs to quickly answer user questions about this website page within **limited context windows** (typically 200K tokens).
+
+**What This Means:**
+- An LLM will read this file to understand "What is this page about?"
+- Users will ask questions like "What does this page offer?", "Who is this for?", "What are the key features?"
+- Content must be **concise**, **scannable**, and **fact-dense**
+- Prioritize information that helps LLMs **infer meaning** over complete content reproduction
+
+---
+
+## \u{1F4E5} Context Supplied
+
+- **URL:** ${request.url}
+- **Template Alias:** ${request.templateAlias}
+- **JSON Path:** ${request.jpath}
+
+### Available Data
+\`\`\`json
+${JSON.stringify(request.pageContent, null, 2)}
+\`\`\`
+
+---
+
+## \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
+
+### 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.
+
+### 3. Prioritize Information by Importance
+**Essential First:**
+- What this page represents
+- Primary value/purpose
+- Key differentiators
+
+**Supporting Details Second:**
+- Features, benefits, specifications
+- Use cases, examples
+- Technical details
+
+**Peripheral Information Last:**
+- Meta information, related links
+- Supplementary context
+
+### 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
+
+---
+
+## \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
+
+### 2. Exact Property Bindings
+- Always use the **exact property name** from JSON: \`{{actualKeyName}}\`
+- Do NOT rename or modify binding identifiers
+- The Mustache bindings must match JSON 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}})\`
+
+### 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\`)
+
+### 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
+
+---
+
+## \u{1F4D0} Template Structure Pattern
+
+### Mandatory Opening
+\`\`\`mustache
+# {{primaryTitle}}
+
+{{#summaryOrTagline}}
+> {{summaryOrTagline}}
+{{/summaryOrTagline}}
+\`\`\`
+
+### Recommended Sections (adapt to JSON)
+\`\`\`mustache
+{{#mainDescription}}
+{{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}}
+\`\`\`
+
+**Note:** This is an illustrative pattern. Adapt section names and structure to match the actual JSON dynamically.
+
+---
+
+## \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
+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
+
+---
+
+## \u{1F680} Your Task
+
+Analyze the provided JSON structure and **generate a Mustache template** that produces an **LLM knowledge base entry** following these principles.
+
+**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?
+
+Generate the template now.
+`;
+}
+
 class AnthropicClient {
   client;
   model;
@@ -49,121 +237,7 @@ class AnthropicClient {
     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 & or /
-- **NO ATTRIBUTES**: No dir="RTL", style="", class="" etc.
-
-Generate the optimized Mustache template:`;
+    return buildLLMSTemplatePrompt(request);
   }
   parseResponse(responseText) {
     const codeBlockRegex = /```(?:mustache)?\n?([\s\S]*?)```/;
@@ -884,245 +958,6 @@ async function performAutomaticCleanup(umbracoData, cacheDir, options = {}) {
   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;
@@ -1267,8 +1102,7 @@ class TemplateGenerator {
   }
   async renderTemplate(template, data) {
     return withErrorHandling(async () => {
-      const validatedTemplate = await templateValidationPipeline.validateAndFix(template);
-      return Mustache.render(validatedTemplate, data);
+      return Mustache.render(template, data);
     }, {
       template: template.substring(0, 200) + "...",
       dataKeys: Object.keys(data)

package/dist/module.json

@@ -4,5 +4,5 @@
   "compatibility": {
     "nuxt": "^3.0.0"
   },
-  "version": "0.1.6"
+  "version": "0.1.8"
 }

package/dist/module.mjs

@@ -1,4 +1,4 @@
-export { l as default } from './shared/nuxt-llms-generator.11eb2a36.mjs';
+export { l as default } from './shared/nuxt-llms-generator.bc139143.mjs';
 import '@nuxt/kit';
 import 'fs';
 import 'path';

package/dist/shared/{nuxt-llms-generator.11eb2a36.mjs → nuxt-llms-generator.bc139143.mjs}

@@ -58,28 +58,6 @@ class SchemaValidator {
   }
 }
 
-var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
-  ErrorCode2["INVALID_CONFIG"] = "INVALID_CONFIG";
-  ErrorCode2["MISSING_API_KEY"] = "MISSING_API_KEY";
-  ErrorCode2["INVALID_DATA_PATH"] = "INVALID_DATA_PATH";
-  ErrorCode2["INVALID_UMBRACO_DATA"] = "INVALID_UMBRACO_DATA";
-  ErrorCode2["PAGE_CONTENT_EXTRACTION_FAILED"] = "PAGE_CONTENT_EXTRACTION_FAILED";
-  ErrorCode2["INVALID_JPATH"] = "INVALID_JPATH";
-  ErrorCode2["ANTHROPIC_API_ERROR"] = "ANTHROPIC_API_ERROR";
-  ErrorCode2["ANTHROPIC_CONNECTION_FAILED"] = "ANTHROPIC_CONNECTION_FAILED";
-  ErrorCode2["TEMPLATE_GENERATION_FAILED"] = "TEMPLATE_GENERATION_FAILED";
-  ErrorCode2["RATE_LIMIT_EXCEEDED"] = "RATE_LIMIT_EXCEEDED";
-  ErrorCode2["TEMPLATE_VALIDATION_FAILED"] = "TEMPLATE_VALIDATION_FAILED";
-  ErrorCode2["TEMPLATE_RENDERING_FAILED"] = "TEMPLATE_RENDERING_FAILED";
-  ErrorCode2["MUSTACHE_SYNTAX_ERROR"] = "MUSTACHE_SYNTAX_ERROR";
-  ErrorCode2["FILE_READ_ERROR"] = "FILE_READ_ERROR";
-  ErrorCode2["FILE_WRITE_ERROR"] = "FILE_WRITE_ERROR";
-  ErrorCode2["DIRECTORY_CREATION_FAILED"] = "DIRECTORY_CREATION_FAILED";
-  ErrorCode2["CACHE_READ_ERROR"] = "CACHE_READ_ERROR";
-  ErrorCode2["CACHE_WRITE_ERROR"] = "CACHE_WRITE_ERROR";
-  ErrorCode2["CACHE_CORRUPTED"] = "CACHE_CORRUPTED";
-  return ErrorCode2;
-})(ErrorCode || {});
 class LLMSError extends Error {
   code;
   context;
@@ -117,12 +95,6 @@ class AnthropicAPIError extends LLMSError {
     this.retryable = retryable;
   }
 }
-class TemplateError extends LLMSError {
-  constructor(code, message, context, cause) {
-    super(code, message, context, cause);
-    this.name = "TemplateError";
-  }
-}
 class FileSystemError extends LLMSError {
   path;
   constructor(code, message, path, context, cause) {
@@ -379,4 +351,4 @@ async function generateLLMSFiles(config, umbracoData, logger) {
   }
 }
 
-export { ErrorCode as E, TemplateError as T, llmsModule as l, withErrorHandling as w };
+export { llmsModule as l, withErrorHandling as w };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voicenter-team/nuxt-llms-generator",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Nuxt 3 module for automatically generating AI-optimized documentation files (llms.txt, llms-full.txt, and individual .md files) from Umbraco CMS data using Anthropic's Claude API.",
   "repository": "https://github.com/VoicenterTeam/nuxt-llms-generator",
   "license": "MIT",