@voicenter-team/nuxt-llms-generator 0.1.0

package/dist/module.cjs

@@ -0,0 +1,5 @@
+module.exports = function(...args) {
+  return import('./module.mjs').then(m => m.default.call(this, ...args))
+}
+const _meta = module.exports.meta = require('./module.json')
+module.exports.getMeta = () => Promise.resolve(_meta)

package/dist/module.d.mts

@@ -0,0 +1,138 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface LLMSConfig {
+    anthropicApiKey: string;
+    umbracoDataPath: string;
+    templatesOutputDir: string;
+    finalOutputDir: string;
+    cacheDir?: string;
+    anthropicModel?: string;
+    maxConcurrent?: number;
+    enableLLMSFullTxt?: boolean;
+    enableIndividualMd?: boolean;
+    enableAutoCleanup?: boolean;
+    cleanupOrphaned?: boolean;
+    cleanupHidden?: boolean;
+}
+interface UmbracoUrlItem {
+    nodeID: number;
+    url: string;
+    Jpath: string;
+    TemplateAlias: string;
+}
+interface UmbracoPageContent {
+    nodeID: number;
+    pageTitle?: string;
+    pageTittle?: string;
+    pageDescription?: string;
+    headerBlockTitle?: string;
+    headerBlockSubtitle?: string;
+    content?: string;
+    title?: string;
+    description?: string;
+    hidePage?: string | number | boolean | null;
+    children?: Record<string, UmbracoPageContent>;
+    [key: string]: any;
+}
+interface UmbracoSiteData {
+    pageTitle?: string;
+    pageDescription?: string;
+    mainHeaderBlockTitle?: string;
+    ogDescription?: string;
+    children?: Record<string, UmbracoPageContent>;
+    [key: string]: any;
+}
+interface UmbracoData {
+    urlList: UmbracoUrlItem[];
+    SiteData: UmbracoSiteData;
+}
+interface PageContentHash {
+    pageId: string;
+    jpath: string;
+    templateAlias: string;
+    structureHash: string;
+    lastUpdated: Date;
+}
+interface TemplateCache {
+    [pageId: string]: {
+        hash: string;
+        template: string;
+        metadata: PageContentHash;
+    };
+}
+interface GeneratedTemplate {
+    pageId: string;
+    templatePath: string;
+    template: string;
+    hash: string;
+    metadata: {
+        url: string;
+        templateAlias: string;
+        jpath: string;
+        generatedAt: Date;
+    };
+}
+interface LLMSFiles {
+    llmsTxt: {
+        path: string;
+        content: string;
+    };
+    llmsFullTxt?: {
+        path: string;
+        content: string;
+    };
+    individualMdFiles?: Array<{
+        path: string;
+        content: string;
+        url: string;
+        pageId: string;
+    }>;
+}
+interface AnthropicGenerationRequest {
+    pageContent: Record<string, any>;
+    templateAlias: string;
+    url: string;
+    jpath: string;
+}
+interface AnthropicGenerationResponse {
+    template: string;
+    metadata?: {
+        title?: string;
+        description?: string;
+        tags?: string[];
+    };
+}
+interface LLMSGeneratorOptions {
+    config: LLMSConfig;
+    umbracoData: UmbracoData;
+    templateCache?: TemplateCache;
+}
+interface PageStructureInfo {
+    keys: string[];
+    excludedKeys: string[];
+    hasChildren: boolean;
+    childrenCount: number;
+}
+interface HashGenerationOptions {
+    excludeChildren?: boolean;
+    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 };

package/dist/module.d.ts

@@ -0,0 +1,138 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface LLMSConfig {
+    anthropicApiKey: string;
+    umbracoDataPath: string;
+    templatesOutputDir: string;
+    finalOutputDir: string;
+    cacheDir?: string;
+    anthropicModel?: string;
+    maxConcurrent?: number;
+    enableLLMSFullTxt?: boolean;
+    enableIndividualMd?: boolean;
+    enableAutoCleanup?: boolean;
+    cleanupOrphaned?: boolean;
+    cleanupHidden?: boolean;
+}
+interface UmbracoUrlItem {
+    nodeID: number;
+    url: string;
+    Jpath: string;
+    TemplateAlias: string;
+}
+interface UmbracoPageContent {
+    nodeID: number;
+    pageTitle?: string;
+    pageTittle?: string;
+    pageDescription?: string;
+    headerBlockTitle?: string;
+    headerBlockSubtitle?: string;
+    content?: string;
+    title?: string;
+    description?: string;
+    hidePage?: string | number | boolean | null;
+    children?: Record<string, UmbracoPageContent>;
+    [key: string]: any;
+}
+interface UmbracoSiteData {
+    pageTitle?: string;
+    pageDescription?: string;
+    mainHeaderBlockTitle?: string;
+    ogDescription?: string;
+    children?: Record<string, UmbracoPageContent>;
+    [key: string]: any;
+}
+interface UmbracoData {
+    urlList: UmbracoUrlItem[];
+    SiteData: UmbracoSiteData;
+}
+interface PageContentHash {
+    pageId: string;
+    jpath: string;
+    templateAlias: string;
+    structureHash: string;
+    lastUpdated: Date;
+}
+interface TemplateCache {
+    [pageId: string]: {
+        hash: string;
+        template: string;
+        metadata: PageContentHash;
+    };
+}
+interface GeneratedTemplate {
+    pageId: string;
+    templatePath: string;
+    template: string;
+    hash: string;
+    metadata: {
+        url: string;
+        templateAlias: string;
+        jpath: string;
+        generatedAt: Date;
+    };
+}
+interface LLMSFiles {
+    llmsTxt: {
+        path: string;
+        content: string;
+    };
+    llmsFullTxt?: {
+        path: string;
+        content: string;
+    };
+    individualMdFiles?: Array<{
+        path: string;
+        content: string;
+        url: string;
+        pageId: string;
+    }>;
+}
+interface AnthropicGenerationRequest {
+    pageContent: Record<string, any>;
+    templateAlias: string;
+    url: string;
+    jpath: string;
+}
+interface AnthropicGenerationResponse {
+    template: string;
+    metadata?: {
+        title?: string;
+        description?: string;
+        tags?: string[];
+    };
+}
+interface LLMSGeneratorOptions {
+    config: LLMSConfig;
+    umbracoData: UmbracoData;
+    templateCache?: TemplateCache;
+}
+interface PageStructureInfo {
+    keys: string[];
+    excludedKeys: string[];
+    hasChildren: boolean;
+    childrenCount: number;
+}
+interface HashGenerationOptions {
+    excludeChildren?: boolean;
+    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 };

package/dist/module.json

@@ -0,0 +1,8 @@
+{
+  "name": "nuxt-llms-generator",
+  "configKey": "llmsGenerator",
+  "compatibility": {
+    "nuxt": "^3.0.0"
+  },
+  "version": "0.1.0"
+}

package/dist/module.mjs

@@ -0,0 +1,5 @@
+export { l as default } from './shared/nuxt-llms-generator.dc009f50.mjs';
+import '@nuxt/kit';
+import 'fs';
+import 'path';
+import 'zod';

package/dist/shared/nuxt-llms-generator.dc009f50.mjs

@@ -0,0 +1,327 @@
+import { defineNuxtModule, useLogger, addTemplate } from '@nuxt/kit';
+import { existsSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+import { z } from 'zod';
+
+const existingPath = z.string().refine(
+  (path) => existsSync(path)
+);
+const anthropicApiKey = z.string().min(10, "API key must be at least 10 characters").regex(/^sk-ant-/, "API key must start with sk-ant-");
+const LLMSConfigSchema = z.object({
+  anthropicApiKey,
+  umbracoDataPath: existingPath,
+  templatesOutputDir: z.string().min(1, "Templates output directory is required"),
+  finalOutputDir: z.string().optional().default("public"),
+  cacheDir: z.string().optional().default(".llms-cache"),
+  anthropicModel: z.string().optional(),
+  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),
+  enableAutoCleanup: z.boolean().optional().default(true),
+  cleanupOrphaned: z.boolean().optional().default(true),
+  cleanupHidden: z.boolean().optional().default(true)
+}).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;
+    }
+  }
+}
+
+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;
+  cause;
+  constructor(code, message, context, cause) {
+    super(message);
+    this.name = "LLMSError";
+    this.code = code;
+    this.context = context;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, LLMSError);
+    }
+  }
+}
+class ConfigurationError extends LLMSError {
+  constructor(message, context, cause) {
+    super("INVALID_CONFIG" /* INVALID_CONFIG */, message, context, cause);
+    this.name = "ConfigurationError";
+  }
+}
+class DataProcessingError extends LLMSError {
+  constructor(code, message, context, cause) {
+    super(code, message, context, cause);
+    this.name = "DataProcessingError";
+  }
+}
+class AnthropicAPIError extends LLMSError {
+  statusCode;
+  retryable;
+  constructor(code, message, statusCode, retryable = false, context, cause) {
+    super(code, message, context, cause);
+    this.name = "AnthropicAPIError";
+    this.statusCode = statusCode;
+    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) {
+    super(code, message, context, cause);
+    this.name = "FileSystemError";
+    this.path = path;
+  }
+}
+class CacheError extends LLMSError {
+  constructor(code, message, context, cause) {
+    super(code, message, context, cause);
+    this.name = "CacheError";
+  }
+}
+class ErrorHandler {
+  static handleError(error, context) {
+    if (error instanceof LLMSError) {
+      return error;
+    }
+    if (error.message.includes("ENOENT")) {
+      return new FileSystemError(
+        "FILE_READ_ERROR" /* FILE_READ_ERROR */,
+        `File not found: ${error.message}`,
+        void 0,
+        context,
+        error
+      );
+    }
+    if (error.message.includes("EACCES")) {
+      return new FileSystemError(
+        "FILE_WRITE_ERROR" /* FILE_WRITE_ERROR */,
+        `Permission denied: ${error.message}`,
+        void 0,
+        context,
+        error
+      );
+    }
+    if (error.message.includes("rate limit")) {
+      return new AnthropicAPIError(
+        "RATE_LIMIT_EXCEEDED" /* RATE_LIMIT_EXCEEDED */,
+        error.message,
+        429,
+        true,
+        context,
+        error
+      );
+    }
+    if (error.message.includes("API key")) {
+      return new ConfigurationError(
+        "Invalid or missing Anthropic API key",
+        context,
+        error
+      );
+    }
+    return new LLMSError(
+      "TEMPLATE_GENERATION_FAILED" /* TEMPLATE_GENERATION_FAILED */,
+      // Default code
+      error.message,
+      context,
+      error
+    );
+  }
+  static logError(error, logger = console) {
+    const logData = {
+      name: error.name,
+      code: error.code,
+      message: error.message,
+      context: error.context,
+      stack: error.stack
+    };
+    if (error instanceof ConfigurationError || error instanceof DataProcessingError) {
+      logger.error("LLMS Generator Error:", logData);
+    } else if (error instanceof AnthropicAPIError && error.retryable) {
+      logger.warn("LLMS API Error (retryable):", logData);
+    } else if (error instanceof CacheError || error instanceof FileSystemError) {
+      logger.error("LLMS System Error:", logData);
+    } else {
+      logger.error("LLMS Unknown Error:", logData);
+    }
+  }
+  static isRetryable(error) {
+    if (error instanceof AnthropicAPIError) {
+      return error.retryable;
+    }
+    if (error.message.includes("network") || error.message.includes("timeout")) {
+      return true;
+    }
+    return false;
+  }
+}
+async function withErrorHandling(operation, context) {
+  try {
+    return await operation();
+  } catch (error) {
+    const llmsError = ErrorHandler.handleError(error instanceof Error ? error : new Error(String(error)), context);
+    ErrorHandler.logError(llmsError);
+    throw llmsError;
+  }
+}
+
+const DEFAULT_OPTIONS = {
+  anthropicModel: "claude-3-7-sonnet-latest",
+  maxConcurrent: 5,
+  enableLLMSFullTxt: true,
+  enableIndividualMd: true,
+  cacheDir: ".llms-cache",
+  finalOutputDir: "public",
+  enableAutoCleanup: true,
+  cleanupOrphaned: true,
+  cleanupHidden: true
+};
+const llmsModule = defineNuxtModule({
+  meta: {
+    name: "nuxt-llms-generator",
+    configKey: "llmsGenerator",
+    compatibility: {
+      nuxt: "^3.0.0"
+    }
+  },
+  defaults: {
+    enabled: true,
+    ...DEFAULT_OPTIONS
+  },
+  async setup(options, nuxt) {
+    const logger = useLogger("llms-generator");
+    if (!options.enabled) {
+      logger.info("LLMS Generator is disabled");
+      return;
+    }
+    if (!options.anthropicApiKey) {
+      logger.warn("No Anthropic API key provided. LLMS Generator will be disabled.");
+      return;
+    }
+    if (!options.umbracoDataPath) {
+      logger.warn("No Umbraco data path provided. LLMS Generator will be disabled.");
+      return;
+    }
+    if (!options.templatesOutputDir) {
+      logger.warn("No templates output directory provided. LLMS Generator will be disabled.");
+      return;
+    }
+    const configForValidation = {
+      anthropicApiKey: options.anthropicApiKey,
+      umbracoDataPath: resolve(nuxt.options.rootDir, options.umbracoDataPath),
+      templatesOutputDir: resolve(nuxt.options.rootDir, options.templatesOutputDir),
+      finalOutputDir: resolve(nuxt.options.rootDir, options.finalOutputDir ?? "public"),
+      cacheDir: options.cacheDir ? resolve(nuxt.options.rootDir, options.cacheDir) : void 0,
+      anthropicModel: options.anthropicModel || DEFAULT_OPTIONS.anthropicModel,
+      maxConcurrent: options.maxConcurrent || DEFAULT_OPTIONS.maxConcurrent,
+      enableLLMSFullTxt: options.enableLLMSFullTxt ?? DEFAULT_OPTIONS.enableLLMSFullTxt,
+      enableIndividualMd: options.enableIndividualMd ?? DEFAULT_OPTIONS.enableIndividualMd,
+      enableAutoCleanup: options.enableAutoCleanup ?? DEFAULT_OPTIONS.enableAutoCleanup,
+      cleanupOrphaned: options.cleanupOrphaned ?? DEFAULT_OPTIONS.cleanupOrphaned,
+      cleanupHidden: options.cleanupHidden ?? DEFAULT_OPTIONS.cleanupHidden
+    };
+    let moduleOptions;
+    try {
+      moduleOptions = SchemaValidator.validateConfig(configForValidation);
+      logger.success("LLMS Generator configuration validated successfully");
+    } catch (error) {
+      logger.error("LLMS Generator configuration validation failed:");
+      const cause = error instanceof Error ? error : new Error(String(error));
+      logger.error(cause.message);
+      throw new ConfigurationError(
+        "Invalid LLMS Generator configuration",
+        { providedConfig: configForValidation },
+        cause
+      );
+    }
+    try {
+      const umbracoDataContent = readFileSync(moduleOptions.umbracoDataPath, "utf-8");
+      const umbracoData = JSON.parse(umbracoDataContent);
+      logger.info(`Loaded Umbraco data with ${umbracoData.urlList.length} pages`);
+      nuxt.options.runtimeConfig.llmsGenerator = {
+        enabled: true,
+        config: moduleOptions,
+        pagesCount: umbracoData.urlList.length
+      };
+      addTemplate({
+        filename: "llms-module-options.mjs",
+        getContents: () => `export default ${JSON.stringify(moduleOptions, null, 2)}`
+      });
+      if (nuxt.options.dev) {
+        logger.info("LLMS Generator: Development mode - templates will be generated on demand");
+      } else {
+        logger.info("LLMS Generator: Production mode - templates and files will be generated during build");
+        nuxt.hook("build:before", async () => {
+          logger.info("Starting LLMS template generation...");
+          await generateLLMSFiles(moduleOptions, umbracoData, logger);
+        });
+      }
+    } catch (error) {
+      logger.error("Failed to load Umbraco data:", error);
+      nuxt.options.runtimeConfig.llmsGenerator = { enabled: false };
+    }
+  }
+});
+async function generateLLMSFiles(config, umbracoData, logger) {
+  try {
+    const { LLMSFilesGenerator } = await import('../chunks/llms-files-generator.mjs');
+    const generator = new LLMSFilesGenerator(config);
+    logger.info("Testing Anthropic API connection...");
+    const connectionOk = await generator["templateGenerator"].testConnection();
+    if (!connectionOk) {
+      logger.warn("Anthropic API connection test failed. Check your API key.");
+      return;
+    }
+    logger.success("Anthropic API connection successful");
+    const files = await generator.generateAllFiles(umbracoData);
+    logger.success("Generated LLMS files:");
+    logger.info(`- llms.txt: ${files.llmsTxt.path}`);
+    if (files.llmsFullTxt) {
+      logger.info(`- llms-full.txt: ${files.llmsFullTxt.path}`);
+    }
+    if (files.individualMdFiles) {
+      logger.info(`- Individual MD files: ${files.individualMdFiles.length}`);
+    }
+  } catch (error) {
+    logger.error("LLMS file generation failed:", error);
+    throw error;
+  }
+}
+
+export { ErrorCode as E, TemplateError as T, llmsModule as l, withErrorHandling as w };

package/dist/types.d.mts

@@ -0,0 +1,8 @@
+
+import type {  } from './module.js'
+
+
+
+
+
+export type { default } from './module.js'

package/dist/types.d.ts

@@ -0,0 +1,8 @@
+
+import type {  } from './module'
+
+
+
+
+
+export type { default } from './module'