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

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

@@ -4,74 +4,38 @@ 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';
 
-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 `# llms\u2011aware Mustache Template Generator Prompt (Key\u2011Agnostic)
+function buildLLMSTemplatePrompt(request) {
+  return `# LLMS.txt-Optimized Mustache Template Generator
 
-You are an expert in crafting **Mustache.js templates** whose output is **clean Markdown pages** (with \`.md\` extension) intended for **LLM-friendly ingestion** following the [\`llms.txt\`](https://llmstxt.org/) standard.
+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} Purpose & Goal
+## \u{1F3AF} TRUE PURPOSE: Help LLMs Answer Questions Efficiently
 
-The \`.md\` files generated from these templates represent the **structured, machine-readable versions of website pages**.
-They are designed to be indexed and understood by **Large Language Models** through the \`llms.txt\` manifest.
-Each \`.md\` file provides semantic, human-readable, and hierarchically organized content for LLMs to learn from.
+**Critical Understanding:**
+These \`.md\` files are **NOT website copies** \u2014 they are **LLM knowledge base entries** designed for **inference** (understanding), not training.
 
-Your task: Given an arbitrary JSON page structure (potentially deeply nested, dynamic, and unpredictable), produce a **generic Mustache template** that renders this JSON into an \`.md\` file conforming to \`llms.txt\` principles \u2014 emphasizing clarity, structure, and interpretability.
+**Primary Goal:** Enable LLMs to quickly answer user questions about this website page within **limited context windows** (typically 200K tokens).
 
-These templates must be domain-agnostic: usable for **B2B SaaS**, **marketplaces**, **landing pages**, **blogs**, **docs**, or **personal websites**.
+**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 to You
+## \u{1F4E5} Context Supplied
 
-- URL: ${request.url}
-- Template Alias: ${request.templateAlias}
-- JSON Path: ${request.jpath}
+- **URL:** ${request.url}
+- **Template Alias:** ${request.templateAlias}
+- **JSON Path:** ${request.jpath}
 
 ### Available Data
 \`\`\`json
@@ -80,102 +44,200 @@ ${JSON.stringify(request.pageContent, null, 2)}
 
 ---
 
-## \u{1F9E9} Core Principles (Key\u2011Agnostic)
+## \u{1F9E0} Content Philosophy: Think "Knowledge Base Entry"
 
-1. **Do not assume fixed property names.**
-   Infer content type and importance dynamically from value structure, length, and position.
+### 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. **Purpose\u2011Driven Hierarchy (LLMS.txt\u2011Friendly):**
-   - Start with the main concept (\`#\` heading)
-   - Follow with a one-paragraph value statement or summary (\`>\` blockquote)
-   - Then expand into structured content with \`##\`, \`###\`, and lists
+### 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. **Semantic Markdown Only**
-   Use only Markdown syntax (\`#\`, \`>\`, \`-\`, \`[link](url)\`, \`![alt](img)\`).
-   **No HTML**, **no entities**, **no inline styles**, **no attributes**.
+### 3. Prioritize Information by Importance
+**Essential First:**
+- What this page represents
+- Primary value/purpose
+- Key differentiators
 
-4. **Dynamic Interpretation**
-   - Short textual fields near the root likely represent titles.
-   - Long text blocks indicate overviews, descriptions, or stories.
-   - Arrays of primitives \u2192 bullet lists.
-   - Arrays of objects \u2192 repeated sub-sections or tables.
-   - Objects \u2192 nested sections with humanized headings.
+**Supporting Details Second:**
+- Features, benefits, specifications
+- Use cases, examples
+- Technical details
 
-5. **Exact Property Bindings**
-   When referencing values, always use the **exact property name** from JSON (\`{{keyName}}\`).
-   Do not rename or modify binding identifiers.
+**Peripheral Information Last:**
+- Meta information, related links
+- Supplementary context
 
-6. **Humanized Section Titles**
-   Convert keys into readable Markdown headings:
-   e.g., \`productDetails\` \u2192 \u201CProduct Details\u201D, \`seo_meta\` \u2192 \u201CSEO Meta\u201D.
-   These headings are for readability; the Mustache bindings remain exact.
+### 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
 
-7. **Omit Noise**
-   Exclude non-content fields like IDs, timestamps, internal flags, etc.
+---
 
-8. **URL Handling**
-   - If a value looks like a URL, render \`[Label]({{key}})\`.
-   - If image URL, render \`![Alt text]({{key}})\`.
+## \u{1F527} Technical Principles (Key-Agnostic Design)
 
-9. **Recursion & Nesting**
-   Apply the same logic recursively to all nested objects and arrays.
-   Heading depth corresponds to the nesting level, but avoid exceeding four \`#\` levels.
+### 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"
 
-## \u{1F9E0} LLMS.txt Relevance
+### 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}})\`
 
-The resulting \`.md\` output should be suitable for inclusion in or referencing from \`llms.txt\`.
-Each file acts as an **LLM-ingestible mirror** of the website content \u2014 optimized for understanding by AI systems.
-Focus on **semantic clarity**, **hierarchical consistency**, and **contextual richness**.
-This ensures that LLMs reading the \`.md\` files will correctly infer what each page is about.
+### 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{1F9F1} Example Structural Patterns
+## \u{1F4D0} Template Structure Pattern
+
+### Mandatory Opening
+\`\`\`mustache
+# {{primaryTitle}}
+
+{{#summaryOrTagline}}
+> {{summaryOrTagline}}
+{{/summaryOrTagline}}
+\`\`\`
 
-### Generic Page Template
+### Recommended Sections (adapt to JSON)
 \`\`\`mustache
-# {{mainTitle}}
+{{#mainDescription}}
+{{mainDescription}}
+{{/mainDescription}}
 
-{{#summary}}
-> {{summary}}
-{{/summary}}
+{{#keyFeatures.0}}
+## Key Features
+{{#keyFeatures}}
+- **{{featureName}}**: {{featureDescription}}
+{{/keyFeatures}}
+{{/keyFeatures.0}}
 
-{{#sections.0}}
-## {{sectionTitle}}
-{{#sections}}
-### {{itemTitle}}
-{{itemDescription}}
-{{/sections}}
-{{/sections.0}}
+{{#useCases.0}}
+## Use Cases
+{{#useCases}}
+### {{caseTitle}}
+{{caseDescription}}
+{{/useCases}}
+{{/useCases.0}}
 
-{{#links.0}}
-## Links
-{{#links}}
-- [{{label}}]({{url}})
-{{/links}}
-{{/links.0}}
+{{#technicalDetails.0}}
+## Technical Details
+{{#technicalDetails}}
+- **{{detailLabel}}**: {{detailValue}}
+{{/technicalDetails}}
+{{/technicalDetails.0}}
 \`\`\`
 
-> Example only \u2014 the actual template must reflect the JSON shape dynamically.
+**Note:** This is an illustrative pattern. Adapt section names and structure to match the actual JSON dynamically.
 
 ---
 
 ## \u2705 Output Requirements
 
-- Output **only** the Mustache template (no extra text, no code fences).
-- Use **exact JSON property names** in bindings.
-- Render **clean, human-readable Markdown** suitable for \`llms.txt\`.
-- Maintain logical hierarchy derived from JSON structure.
-- Avoid domain-specific or brand-specific logic.
+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} Task
+## \u{1F680} Your Task
 
-Analyze the provided JSON and **generate the Mustache template** that will produce the \`.md\` page following these rules.
+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;
+  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 buildLLMSTemplatePrompt(request);
   }
   parseResponse(responseText) {
     const codeBlockRegex = /```(?:mustache)?\n?([\s\S]*?)```/;
@@ -896,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;
@@ -1279,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.7"
+  "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.7",
+  "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",