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

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

@@ -4,10 +4,10 @@ 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.ab079b9f.mjs';
-import { NodeHtmlMarkdown } from 'node-html-markdown';
+import { T as TemplateError, E as ErrorCode, w as withErrorHandling } from '../shared/nuxt-llms-generator.11eb2a36.mjs';
 import '@nuxt/kit';
 import 'zod';
+import 'node-html-markdown';
 
 class AnthropicClient {
   client;
@@ -1128,13 +1128,10 @@ class TemplateGenerator {
   promptAnalyzer;
   cache;
   config;
-  nhm = new NodeHtmlMarkdown(
-    {},
-    void 0,
-    void 0
-  );
-  constructor(config) {
+  umbracoData;
+  constructor(config, umbracoData) {
     this.config = config;
+    this.umbracoData = umbracoData;
     this.anthropicClient = new AnthropicClient(config);
     this.promptAnalyzer = new PromptAnalyzer();
     this.cache = new LLMSCache(config.templatesDir || "./.llms-templates");
@@ -1153,22 +1150,26 @@ class TemplateGenerator {
     }
     return await this.generateTemplateWithAI(pageContent, urlItem);
   }
-  async generateAllTemplates(umbracoData) {
+  async generateAllTemplates() {
     const templates = [];
     const maxConcurrent = this.config.maxConcurrent || 5;
-    await performAutomaticCleanup(umbracoData, this.config.templatesDir || "./.llms-templates", {
-      enableAutoCleanup: this.config.enableAutoCleanup ?? true,
-      cleanupOrphaned: this.config.cleanupOrphaned ?? true,
-      cleanupHidden: this.config.cleanupHidden ?? true,
-      dryRun: false
-    });
-    const visibilityStats = getPageVisibilityStats(umbracoData);
+    await performAutomaticCleanup(
+      this.umbracoData,
+      this.config.templatesDir || "./.llms-templates",
+      {
+        enableAutoCleanup: this.config.enableAutoCleanup ?? true,
+        cleanupOrphaned: this.config.cleanupOrphaned ?? true,
+        cleanupHidden: this.config.cleanupHidden ?? true,
+        dryRun: false
+      }
+    );
+    const visibilityStats = getPageVisibilityStats(this.umbracoData);
     console.log("\u{1F4CA} Page visibility stats:", visibilityStats);
-    const visiblePages = umbracoData.urlList.filter(
-      (urlItem) => shouldGenerateTemplate(umbracoData, urlItem)
+    const visiblePages = this.umbracoData.urlList.filter(
+      (urlItem) => shouldGenerateTemplate(this.umbracoData, urlItem)
     );
-    console.log(`Checking ${visiblePages.length}/${umbracoData.urlList.length} visible pages for cache status...`);
-    const { cached, needGeneration } = this.identifyTemplatesNeeded(umbracoData, visiblePages);
+    console.log(`Checking ${visiblePages.length}/${this.umbracoData.urlList.length} visible pages for cache status...`);
+    const { cached, needGeneration } = this.identifyTemplatesNeeded(visiblePages);
     console.log(`\u{1F4C8} Template status: ${cached.length} cached, ${needGeneration.length} need generation`);
     templates.push(...cached);
     if (needGeneration.length === 0) {
@@ -1197,11 +1198,11 @@ class TemplateGenerator {
     console.log(`Generated ${templates.length} total templates (${cached.length} from cache, ${templates.length - cached.length} newly generated)`);
     return templates;
   }
-  identifyTemplatesNeeded(umbracoData, visiblePages) {
+  identifyTemplatesNeeded(visiblePages) {
     const cached = [];
     const needGeneration = [];
     for (const urlItem of visiblePages) {
-      const pageContent = extractPageContent(umbracoData, urlItem.Jpath);
+      const pageContent = extractPageContent(this.umbracoData, urlItem.Jpath);
       if (!pageContent) {
         console.warn(`No content found for ${urlItem.url} (${urlItem.Jpath})`);
         continue;
@@ -1267,11 +1268,7 @@ class TemplateGenerator {
   async renderTemplate(template, data) {
     return withErrorHandling(async () => {
       const validatedTemplate = await templateValidationPipeline.validateAndFix(template);
-      const renderedContent = Mustache.render(validatedTemplate, data);
-      if (this.config.enableHtmlToMarkdown) {
-        return this.nhm.translate(renderedContent);
-      }
-      return renderedContent;
+      return Mustache.render(validatedTemplate, data);
     }, {
       template: template.substring(0, 200) + "...",
       dataKeys: Object.keys(data)
@@ -1325,21 +1322,22 @@ class TemplateGenerator {
 class LLMSFilesGenerator {
   config;
   templateGenerator;
-  nhm = new NodeHtmlMarkdown();
-  constructor(config) {
+  umbracoData;
+  constructor(config, umbracoData) {
     this.config = config;
-    this.templateGenerator = new TemplateGenerator(config);
+    this.umbracoData = umbracoData;
+    this.templateGenerator = new TemplateGenerator(config, umbracoData);
   }
-  async generateAllFiles(umbracoData) {
+  async generateAllFiles() {
     const startTime = Date.now();
     console.log("\u{1F680} Starting LLMS files generation...");
-    const templates = await this.templateGenerator.generateAllTemplates(umbracoData);
+    const templates = await this.templateGenerator.generateAllTemplates();
     console.log("\u{1F4C4} Generating individual markdown files...");
-    const individualMdFiles = this.config.enableIndividualMd ? await this.generateIndividualMarkdownFiles(umbracoData, templates) : void 0;
+    const individualMdFiles = this.config.enableIndividualMd ? await this.generateIndividualMarkdownFiles(templates) : void 0;
     console.log("\u{1F4DD} Generating llms.txt navigation file...");
-    const llmsTxt = this.generateLLMSTxt(umbracoData, individualMdFiles || []);
+    const llmsTxt = this.generateLLMSTxt(individualMdFiles || []);
     console.log("\u{1F4DA} Generating llms-full.txt...");
-    const llmsFullTxt = this.config.enableLLMSFullTxt ? this.generateLLMSFullTxt(umbracoData, individualMdFiles || []) : void 0;
+    const llmsFullTxt = this.config.enableLLMSFullTxt ? this.generateLLMSFullTxt(individualMdFiles || []) : void 0;
     const files = {
       llmsTxt,
       llmsFullTxt,
@@ -1350,18 +1348,18 @@ class LLMSFilesGenerator {
     console.log(`\u2705 LLMS files generation completed in ${duration}ms`);
     return files;
   }
-  async generateIndividualMarkdownFiles(umbracoData, templates) {
+  async generateIndividualMarkdownFiles(templates) {
     const mdFiles = [];
     for (const template of templates) {
       try {
-        const urlItem = umbracoData.urlList.find(
+        const urlItem = this.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);
+        const pageContent = extractPageContent(this.umbracoData, urlItem.Jpath);
         if (!pageContent) {
           console.warn(`Page content not found for ${urlItem.url}`);
           continue;
@@ -1385,9 +1383,9 @@ class LLMSFilesGenerator {
     }
     return mdFiles;
   }
-  generateLLMSTxt(umbracoData, mdFiles) {
-    const siteTitle = this.extractSiteTitle(umbracoData);
-    const siteDescription = this.extractSiteDescription(umbracoData);
+  generateLLMSTxt(mdFiles) {
+    const siteTitle = this.extractSiteTitle();
+    const siteDescription = this.extractSiteDescription();
     let content = `# ${siteTitle}
 
 `;
@@ -1399,7 +1397,7 @@ class LLMSFilesGenerator {
     content += `This website contains comprehensive information about ${siteTitle.toLowerCase()}. The content is organized into the following sections:
 
 `;
-    const pagesByCategory = this.groupPagesByCategory(umbracoData, mdFiles);
+    const pagesByCategory = this.groupPagesByCategory(mdFiles);
     for (const [category, pages] of Object.entries(pagesByCategory)) {
       if (pages.length === 0)
         continue;
@@ -1407,33 +1405,32 @@ class LLMSFilesGenerator {
 
 `;
       for (const page of pages) {
-        const urlItem = umbracoData.urlList.find((item) => item.url === page.url);
-        const pageTitle = this.extractPageTitle(umbracoData, urlItem);
+        const urlItem = this.umbracoData.urlList.find((item) => item.url === page.url);
+        const pageTitle = this.extractPageTitle(urlItem);
         const relativeFilePath = this.getLLMSFilePath(page.path);
-        content += `- [${pageTitle}](${relativeFilePath}): ${this.generatePageDescription(umbracoData, urlItem)}
+        content += `- [${pageTitle}](${relativeFilePath}): ${this.generatePageDescription(urlItem)}
 `;
       }
       content += "\n";
     }
-    const visiblePages = getVisiblePages(umbracoData);
-    const hiddenCount = umbracoData.urlList.length - visiblePages.length;
+    const visiblePages = getVisiblePages(this.umbracoData);
+    const hiddenCount = this.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";
+    content += `- [Complete Documentation](${this.makeUrl("/llms-full.txt")}): All content combined in a single file`;
     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);
+  generateLLMSFullTxt(mdFiles) {
+    const siteTitle = this.extractSiteTitle();
+    const siteDescription = this.extractSiteDescription();
     let content = `# ${siteTitle} - Complete Documentation
 
 `;
@@ -1444,15 +1441,10 @@ class LLMSFilesGenerator {
     }
     content += "---\n\n";
     for (const mdFile of mdFiles) {
-      const urlItem = umbracoData.urlList.find((item) => item.url === mdFile.url);
+      const urlItem = this.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 += `## Page: ${this.makeUrl(mdFile.url)}
 
 `;
       content += mdFile.content;
@@ -1481,111 +1473,127 @@ class LLMSFilesGenerator {
       console.log(`\u{1F4DD} Saved: ${files.individualMdFiles.length} markdown files to llms/ subdirectory`);
     }
   }
-  groupPagesByCategory(umbracoData, mdFiles) {
-    const categories = {
-      main: [],
-      blog: [],
-      services: [],
-      products: [],
-      info: [],
-      other: []
-    };
+  /**
+  * Groups pages by their first-level URL segment.
+  * Example:
+  *   /ai-marketplace        -> category "ai-marketplace"
+  *   /ai-marketplace/asda   -> category "ai-marketplace"
+  *   /marketplace           -> category "marketplace"
+  *   /                      -> category "main"
+  */
+  groupPagesByCategory(mdFiles) {
+    const categories = {};
     for (const mdFile of mdFiles) {
-      const urlItem = umbracoData.urlList.find((item) => item.url === mdFile.url);
+      const urlItem = this.umbracoData.urlList.find((item) => item.url === mdFile.url);
       if (!urlItem)
         continue;
       const category = this.categorizeUrlItem(urlItem);
-      if (!categories[category]) {
+      if (!categories[category])
         categories[category] = [];
-      }
       categories[category].push(mdFile);
     }
     return categories;
   }
+  /**
+  * Determines a logical category name based on the URL structure.
+  * Uses the first path segment as the category.
+  */
   categorizeUrlItem(urlItem) {
-    const { url, TemplateAlias } = urlItem;
-    const alias = (TemplateAlias || "unknown").toLowerCase();
-    url.toLowerCase();
-    if (url === "/" || alias.includes("home"))
+    const url = urlItem.url.toLowerCase().trim();
+    if (url === "/" || url === "")
       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;
+    const cleaned = url.replace(/^https?:\/\/[^/]+/, "").replace(/\/+$/, "");
+    const segments = cleaned.split("/").filter(Boolean);
+    if (segments.length === 0)
+      return "main";
+    const firstSegment = segments[0];
+    const ignored = ["media", "assets", "static", "files", "uploads"];
+    if (ignored.includes(firstSegment))
+      return "other";
+    if (firstSegment.length < 2 || /^\d+$/.test(firstSegment))
+      return "other";
+    return firstSegment;
+  }
+  /**
+   * Returns a formatted, human-readable category name for llms.txt output.
+    */
+  formatCategoryName(category) {
+    if (category === "main")
+      return "Main Pages";
+    if (category === "other")
+      return "Other Pages";
+    return category.split("-").map((word) => word.length <= 3 ? word.toUpperCase() : word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  }
+  extractSiteTitle() {
+    const siteData = this.umbracoData.SiteData;
     const rawTitle = siteData?.pageTitle || siteData?.mainHeaderBlockTitle || "Website Documentation";
-    return this.cleanHtmlContent(rawTitle);
+    return rawTitle;
   }
-  extractSiteDescription(umbracoData) {
-    const siteData = umbracoData.SiteData;
+  extractSiteDescription() {
+    const siteData = this.umbracoData.SiteData;
     const rawDescription = siteData?.pageDescription || siteData?.ogDescription || null;
-    return rawDescription ? this.cleanHtmlContent(rawDescription) : null;
-  }
-  cleanHtmlContent(content) {
-    if (!this.config.enableHtmlToMarkdown) {
-      return content;
-    }
-    if (/<[^>]+>/.test(content)) {
-      return this.nhm.translate(content).trim();
-    }
-    return content;
+    return rawDescription ? rawDescription : null;
   }
-  extractPageTitle(umbracoData, urlItem) {
+  extractPageTitle(urlItem) {
     if (!urlItem)
       return "Untitled Page";
-    const pageContent = extractPageContent(umbracoData, urlItem.Jpath);
+    const pageContent = extractPageContent(this.umbracoData, urlItem.Jpath);
     if (!pageContent)
       return urlItem.TemplateAlias;
-    return pageContent.pageTitle || pageContent.title || pageContent.headerBlockTitle || urlItem.TemplateAlias;
+    return String(
+      pageContent.pageTitle || pageContent.title || pageContent.pageTittle || urlItem.TemplateAlias
+    );
   }
-  generatePageDescription(umbracoData, urlItem) {
+  generatePageDescription(urlItem) {
     if (!urlItem)
       return "Page information";
-    const pageContent = extractPageContent(umbracoData, urlItem.Jpath);
+    const pageContent = extractPageContent(this.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 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) {
-    let filename = url.replace(/^\//, "").replace(/\/$/, "").replace(/\//g, "-").replace(/[^a-zA-Z0-9\-_.]/g, "").replace(/--+/g, "-").replace(/^-+|-+$/g, "");
+    if (url === "/") {
+      return "index";
+    }
+    let filename = url.replace(/^\//, "").replace(/\/$/, "").replace(/\//g, "-").replace(/--+/g, "-").replace(/^-+|-+$/g, "");
     if (!filename || filename === "") {
-      filename = "index";
+      filename = `index_${url.length}_${Date.now()}`;
     }
     if (filename.startsWith("-") || filename.startsWith(".")) {
       filename = "page-" + filename.replace(/^[-.]/, "");
     }
     return filename;
   }
-  getRelativeFilePath(fullPath) {
-    const filename = fullPath.split("/").pop() || "";
-    return filename;
-  }
   getLLMSFilePath(fullPath) {
     const filename = basename(fullPath);
-    return `/llms/${filename}`;
+    return this.makeUrl(`/llms/${filename}`);
   }
   getOutputDir() {
     return this.config.finalOutputDir || "dist";
   }
+  getBaseSiteUrl() {
+    if (this.config.baseSiteUrl) {
+      return this.config.baseSiteUrl;
+    } else if (this.config.baseSiteUrlUmbracoDataKey) {
+      return this.config.baseSiteUrlUmbracoDataKey in this.umbracoData.SiteData ? String(this.umbracoData.SiteData[this.config.baseSiteUrlUmbracoDataKey]) : "";
+    }
+    return "";
+  }
+  makeUrl(path) {
+    const base = this.getBaseSiteUrl();
+    try {
+      return new URL(path, base).toString();
+    } catch {
+      const baseClean = base?.replace(/\/+$/, "") || "";
+      const pathClean = path?.replace(/^\/+/, "") || "";
+      return baseClean && pathClean ? `${baseClean}/${pathClean}` : baseClean || pathClean;
+    }
+  }
 }
 
 export { LLMSFilesGenerator };

package/dist/module.d.mts

@@ -1,19 +1,33 @@
 import * as _nuxt_schema from '@nuxt/schema';
+import { z } from 'zod';
 
-interface LLMSConfig {
-    anthropicApiKey: string;
-    umbracoDataPath: string;
-    templatesDir: string;
-    finalOutputDir: string;
-    anthropicModel?: string;
-    maxConcurrent?: number;
-    enableLLMSFullTxt?: boolean;
-    enableIndividualMd?: boolean;
-    enableAutoCleanup?: boolean;
-    cleanupOrphaned?: boolean;
-    cleanupHidden?: boolean;
-    enableHtmlToMarkdown?: boolean;
+/**
+ * Zod validation schemas for LLMS generator
+ */
+
+declare const LLMSConfigSchema: z.ZodObject<{
+    anthropicApiKey: z.ZodString;
+    umbracoDataPath: z.ZodString;
+    templatesDir: z.ZodString;
+    finalOutputDir: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    anthropicModel: z.ZodOptional<z.ZodString>;
+    baseSiteUrl: z.ZodOptional<z.ZodString>;
+    baseSiteUrlUmbracoDataKey: z.ZodOptional<z.ZodString>;
+    maxConcurrent: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    enableLLMSFullTxt: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    enableIndividualMd: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    enableAutoCleanup: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    cleanupOrphaned: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    cleanupHidden: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    enableHtmlToMarkdown: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strict>;
+type ValidatedLLMSConfig = z.infer<typeof LLMSConfigSchema>;
+
+interface LLMSModuleOptions extends Partial<ValidatedLLMSConfig> {
+    enabled?: boolean;
 }
+declare const _default: _nuxt_schema.NuxtModule<LLMSModuleOptions, LLMSModuleOptions, false>;
+
 interface UmbracoUrlItem {
     nodeID: number;
     url: string;
@@ -98,11 +112,6 @@ interface AnthropicGenerationResponse {
         tags?: string[];
     };
 }
-interface LLMSGeneratorOptions {
-    config: LLMSConfig;
-    umbracoData: UmbracoData;
-    templateCache?: TemplateCache;
-}
 interface PageStructureInfo {
     keys: string[];
     excludedKeys: string[];
@@ -114,21 +123,6 @@ interface HashGenerationOptions {
     excludeKeys?: string[];
     includeOnlyKeys?: string[];
 }
-interface GenerationStats {
-    totalPages: number;
-    templatesGenerated: number;
-    templatesFromCache: number;
-    mdFilesGenerated: number;
-    llmsTxtGenerated: true;
-    llmsFullTxtGenerated: boolean;
-    duration: number;
-    apiCallsUsed: number;
-}
-
-interface LLMSModuleOptions extends Partial<LLMSConfig> {
-    enabled?: boolean;
-}
-declare const _default: _nuxt_schema.NuxtModule<LLMSModuleOptions, LLMSModuleOptions, false>;
 
 export { _default as default };
-export type { AnthropicGenerationRequest, AnthropicGenerationResponse, GeneratedTemplate, GenerationStats, HashGenerationOptions, LLMSConfig, LLMSFiles, LLMSGeneratorOptions, PageContentHash, PageStructureInfo, TemplateCache, UmbracoData, UmbracoPageContent, UmbracoSiteData, UmbracoUrlItem };
+export type { AnthropicGenerationRequest, AnthropicGenerationResponse, GeneratedTemplate, HashGenerationOptions, LLMSFiles, PageContentHash, PageStructureInfo, TemplateCache, UmbracoData, UmbracoPageContent, UmbracoSiteData, UmbracoUrlItem };

package/dist/module.d.ts

@@ -1,19 +1,33 @@
 import * as _nuxt_schema from '@nuxt/schema';
+import { z } from 'zod';
 
-interface LLMSConfig {
-    anthropicApiKey: string;
-    umbracoDataPath: string;
-    templatesDir: string;
-    finalOutputDir: string;
-    anthropicModel?: string;
-    maxConcurrent?: number;
-    enableLLMSFullTxt?: boolean;
-    enableIndividualMd?: boolean;
-    enableAutoCleanup?: boolean;
-    cleanupOrphaned?: boolean;
-    cleanupHidden?: boolean;
-    enableHtmlToMarkdown?: boolean;
+/**
+ * Zod validation schemas for LLMS generator
+ */
+
+declare const LLMSConfigSchema: z.ZodObject<{
+    anthropicApiKey: z.ZodString;
+    umbracoDataPath: z.ZodString;
+    templatesDir: z.ZodString;
+    finalOutputDir: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    anthropicModel: z.ZodOptional<z.ZodString>;
+    baseSiteUrl: z.ZodOptional<z.ZodString>;
+    baseSiteUrlUmbracoDataKey: z.ZodOptional<z.ZodString>;
+    maxConcurrent: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    enableLLMSFullTxt: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    enableIndividualMd: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    enableAutoCleanup: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    cleanupOrphaned: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    cleanupHidden: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    enableHtmlToMarkdown: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strict>;
+type ValidatedLLMSConfig = z.infer<typeof LLMSConfigSchema>;
+
+interface LLMSModuleOptions extends Partial<ValidatedLLMSConfig> {
+    enabled?: boolean;
 }
+declare const _default: _nuxt_schema.NuxtModule<LLMSModuleOptions, LLMSModuleOptions, false>;
+
 interface UmbracoUrlItem {
     nodeID: number;
     url: string;
@@ -98,11 +112,6 @@ interface AnthropicGenerationResponse {
         tags?: string[];
     };
 }
-interface LLMSGeneratorOptions {
-    config: LLMSConfig;
-    umbracoData: UmbracoData;
-    templateCache?: TemplateCache;
-}
 interface PageStructureInfo {
     keys: string[];
     excludedKeys: string[];
@@ -114,21 +123,6 @@ interface HashGenerationOptions {
     excludeKeys?: string[];
     includeOnlyKeys?: string[];
 }
-interface GenerationStats {
-    totalPages: number;
-    templatesGenerated: number;
-    templatesFromCache: number;
-    mdFilesGenerated: number;
-    llmsTxtGenerated: true;
-    llmsFullTxtGenerated: boolean;
-    duration: number;
-    apiCallsUsed: number;
-}
-
-interface LLMSModuleOptions extends Partial<LLMSConfig> {
-    enabled?: boolean;
-}
-declare const _default: _nuxt_schema.NuxtModule<LLMSModuleOptions, LLMSModuleOptions, false>;
 
 export { _default as default };
-export type { AnthropicGenerationRequest, AnthropicGenerationResponse, GeneratedTemplate, GenerationStats, HashGenerationOptions, LLMSConfig, LLMSFiles, LLMSGeneratorOptions, PageContentHash, PageStructureInfo, TemplateCache, UmbracoData, UmbracoPageContent, UmbracoSiteData, UmbracoUrlItem };
+export type { AnthropicGenerationRequest, AnthropicGenerationResponse, GeneratedTemplate, HashGenerationOptions, LLMSFiles, PageContentHash, PageStructureInfo, TemplateCache, UmbracoData, UmbracoPageContent, UmbracoSiteData, UmbracoUrlItem };

package/dist/module.json

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

package/dist/module.mjs

@@ -1,5 +1,6 @@
-export { l as default } from './shared/nuxt-llms-generator.ab079b9f.mjs';
+export { l as default } from './shared/nuxt-llms-generator.11eb2a36.mjs';
 import '@nuxt/kit';
 import 'fs';
 import 'path';
 import 'zod';
+import 'node-html-markdown';

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

@@ -2,6 +2,7 @@ import { defineNuxtModule, useLogger, addTemplate } from '@nuxt/kit';
 import { existsSync, readFileSync } from 'fs';
 import { resolve } from 'path';
 import { z } from 'zod';
+import { NodeHtmlMarkdown } from 'node-html-markdown';
 
 const existingPath = z.string().refine(
   (path) => existsSync(path)
@@ -13,6 +14,29 @@ const LLMSConfigSchema = z.object({
   templatesDir: z.string().min(1, "Templates directory is required"),
   finalOutputDir: z.string().optional().default("public"),
   anthropicModel: z.string().optional(),
+  baseSiteUrl: z.string().optional().refine((url) => {
+    try {
+      if (!url) {
+        return true;
+      }
+      const parsed = new URL(url);
+      if (!["http:", "https:"].includes(parsed.protocol))
+        return false;
+      if (parsed.pathname !== "" && parsed.pathname !== "/")
+        return false;
+      if (parsed.pathname === "/") {
+        if (url.endsWith("/"))
+          return false;
+      }
+      return !(parsed.search || parsed.hash);
+    } catch {
+      return false;
+    }
+  }, "Must be a base domain URL like 'https://example.com' (no path, no trailing slash)").refine(
+    (url) => !url || !url.endsWith("/"),
+    "Must not end with a trailing slash"
+  ).describe("The base URL of the website to append to links in generated llms files"),
+  baseSiteUrlUmbracoDataKey: z.string().optional().describe("If the SiteData of UmbracoData has the key with the base URL you can pass here the key to auto extract the base url"),
   maxConcurrent: z.number().int().min(1, "maxConcurrent must be at least 1").max(10, "maxConcurrent should not exceed 10 to avoid rate limits").optional().default(3),
   enableLLMSFullTxt: z.boolean().optional().default(true),
   enableIndividualMd: z.boolean().optional().default(true),
@@ -20,19 +44,17 @@ const LLMSConfigSchema = z.object({
   cleanupOrphaned: z.boolean().optional().default(true),
   cleanupHidden: z.boolean().optional().default(true),
   enableHtmlToMarkdown: z.boolean().optional().default(true)
-}).strict();
+}).refine(
+  (data) => data.baseSiteUrl || data.baseSiteUrlUmbracoDataKey,
+  {
+    message: 'At least one of "baseSiteUrl" or "baseSiteUrlUmbracoDataKey" must be provided.',
+    path: ["baseSiteUrl"]
+    // or omit 'path' to make it a general error
+  }
+).strict();
 class SchemaValidator {
   static validateConfig(config) {
-    try {
-      return LLMSConfigSchema.parse(config);
-    } catch (error) {
-      if (error instanceof z.ZodError) {
-        const { errors } = z.treeifyError(error);
-        const message = ["Configuration validation failed:", ...errors].join("\n");
-        throw new Error(message);
-      }
-      throw error;
-    }
+    return LLMSConfigSchema.parse(config);
   }
 }
 
@@ -201,6 +223,33 @@ async function withErrorHandling(operation, context) {
   }
 }
 
+const nhm = new NodeHtmlMarkdown();
+function convertHtmlToMarkdownDeep(input) {
+  if (input === null || input === void 0)
+    return input;
+  if (typeof input === "string") {
+    if (/<[a-z][\s\S]*>/i.test(input)) {
+      try {
+        return nhm.translate(input).trim();
+      } catch {
+        return input;
+      }
+    }
+    return input;
+  }
+  if (Array.isArray(input)) {
+    return input.map(convertHtmlToMarkdownDeep);
+  }
+  if (typeof input === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(input)) {
+      result[key] = convertHtmlToMarkdownDeep(value);
+    }
+    return result;
+  }
+  return input;
+}
+
 const DEFAULT_OPTIONS = {
   anthropicModel: "claude-3-7-sonnet-latest",
   maxConcurrent: 5,
@@ -255,7 +304,9 @@ const llmsModule = defineNuxtModule({
       enableAutoCleanup: options.enableAutoCleanup ?? DEFAULT_OPTIONS.enableAutoCleanup,
       cleanupOrphaned: options.cleanupOrphaned ?? DEFAULT_OPTIONS.cleanupOrphaned,
       cleanupHidden: options.cleanupHidden ?? DEFAULT_OPTIONS.cleanupHidden,
-      enableHtmlToMarkdown: options.enableHtmlToMarkdown ?? DEFAULT_OPTIONS.enableHtmlToMarkdown
+      enableHtmlToMarkdown: options.enableHtmlToMarkdown ?? DEFAULT_OPTIONS.enableHtmlToMarkdown,
+      baseSiteUrl: options.baseSiteUrl,
+      baseSiteUrlUmbracoDataKey: options.baseSiteUrlUmbracoDataKey
     };
     let moduleOptions;
     try {
@@ -273,7 +324,10 @@ const llmsModule = defineNuxtModule({
     }
     try {
       const umbracoDataContent = readFileSync(moduleOptions.umbracoDataPath, "utf-8");
-      const umbracoData = JSON.parse(umbracoDataContent);
+      let umbracoData = JSON.parse(umbracoDataContent);
+      if (moduleOptions.enableHtmlToMarkdown) {
+        umbracoData = convertHtmlToMarkdownDeep(umbracoData);
+      }
       logger.info(`Loaded Umbraco data with ${umbracoData.urlList.length} pages`);
       nuxt.options.runtimeConfig.llmsGenerator = {
         enabled: true,
@@ -302,7 +356,7 @@ const llmsModule = defineNuxtModule({
 async function generateLLMSFiles(config, umbracoData, logger) {
   try {
     const { LLMSFilesGenerator } = await import('../chunks/llms-files-generator.mjs');
-    const generator = new LLMSFilesGenerator(config);
+    const generator = new LLMSFilesGenerator(config, umbracoData);
     logger.info("Testing Anthropic API connection...");
     const connectionOk = await generator["templateGenerator"].testConnection();
     if (!connectionOk) {
@@ -310,7 +364,7 @@ async function generateLLMSFiles(config, umbracoData, logger) {
       return;
     }
     logger.success("Anthropic API connection successful");
-    const files = await generator.generateAllFiles(umbracoData);
+    const files = await generator.generateAllFiles();
     logger.success("Generated LLMS files:");
     logger.info(`- llms.txt: ${files.llmsTxt.path}`);
     if (files.llmsFullTxt) {

package/package.json

@@ -1,16 +1,10 @@
 {
   "name": "@voicenter-team/nuxt-llms-generator",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "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": "your-org/my-module",
+  "repository": "https://github.com/VoicenterTeam/nuxt-llms-generator",
   "license": "MIT",
   "type": "module",
-  "jiti": {
-    "alias": {
-      "@": "./src",
-      "@/*": "./src/*"
-    }
-  },
   "exports": {
     ".": {
       "types": "./dist/types.d.ts",