geo-semantic-layer 3.0.0-alpha.1 → 3.0.0

package/dist/auditor.js

@@ -0,0 +1,2067 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { z } from 'zod';
+import { encode } from 'gpt-tokenizer';
+
+// src/auditor/project-scanner.ts
+var DEFAULT_INCLUDE_PATTERNS = [
+  "**/*.tsx",
+  "**/*.jsx",
+  "**/*.vue",
+  "**/*.astro",
+  "**/*.js",
+  "**/*.ts"
+];
+var DEFAULT_EXCLUDE_PATTERNS = [
+  "node_modules/**",
+  "dist/**",
+  "build/**",
+  ".next/**",
+  ".nuxt/**",
+  ".astro/**",
+  "coverage/**",
+  "**/*.test.{ts,tsx,js,jsx}",
+  "**/*.spec.{ts,tsx,js,jsx}"
+];
+var GENERATOR_PATTERNS = [
+  /generate(Article|Product|Organization|LocalBusiness|Person|Event|WebPage|FAQ|Breadcrumb|OpenGraph)Schema/g,
+  /new\s+(Article|Product|Organization|LocalBusiness|Person|Event|WebPage|FAQ|Breadcrumb)Schema/g
+];
+async function scanProject(options = {}) {
+  const rootDir = options.rootDir || process.cwd();
+  const include = options.include || DEFAULT_INCLUDE_PATTERNS;
+  const exclude = options.exclude || DEFAULT_EXCLUDE_PATTERNS;
+  const framework = await detectFramework(rootDir);
+  const allFiles = await getAllFiles(rootDir, {
+    include,
+    exclude,
+    ...options.maxDepth && { maxDepth: options.maxDepth }
+  });
+  const filesWithSchemas = [];
+  const routesWithoutSchemas = [];
+  for (const filePath of allFiles) {
+    const content = await fs.readFile(filePath, "utf-8");
+    const relativePath = path.relative(rootDir, filePath);
+    const schemas = await detectSchemasInFile(content);
+    if (schemas.length > 0) {
+      filesWithSchemas.push({
+        filePath: relativePath,
+        fileType: path.extname(filePath).slice(1),
+        schemas,
+        linesOfCode: content.split("\n").length
+      });
+    } else if (isRouteFile(filePath, framework)) {
+      const routeInfo = analyzeRouteFile(content, filePath, framework);
+      if (routeInfo) {
+        routesWithoutSchemas.push({
+          filePath: relativePath,
+          ...routeInfo
+        });
+      }
+    }
+  }
+  return {
+    projectRoot: rootDir,
+    framework,
+    filesScanned: allFiles.length,
+    filesWithSchemas,
+    routesWithoutSchemas,
+    scannedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function detectFramework(rootDir) {
+  const configFiles = {
+    next: ["next.config.js", "next.config.mjs", "next.config.ts"],
+    nuxt: ["nuxt.config.js", "nuxt.config.ts"],
+    astro: ["astro.config.mjs", "astro.config.ts"],
+    vite: ["vite.config.js", "vite.config.ts"]
+  };
+  for (const [framework, files] of Object.entries(configFiles)) {
+    for (const file of files) {
+      try {
+        await fs.access(path.join(rootDir, file));
+        return framework;
+      } catch {
+      }
+    }
+  }
+  return "unknown";
+}
+async function getAllFiles(dir, options, currentDepth = 0) {
+  const files = [];
+  if (options.maxDepth && currentDepth > options.maxDepth) {
+    return files;
+  }
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = path.relative(process.cwd(), fullPath);
+      if (isExcluded(relativePath, options.exclude)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        const subFiles = await getAllFiles(fullPath, options, currentDepth + 1);
+        files.push(...subFiles);
+      } else if (entry.isFile()) {
+        if (matchesPatterns(relativePath, options.include)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not read directory ${dir}`);
+  }
+  return files;
+}
+function isExcluded(filePath, excludePatterns) {
+  return excludePatterns.some((pattern) => {
+    const regex = globToRegex(pattern);
+    return regex.test(filePath);
+  });
+}
+function matchesPatterns(filePath, includePatterns) {
+  return includePatterns.some((pattern) => {
+    const regex = globToRegex(pattern);
+    return regex.test(filePath);
+  });
+}
+function globToRegex(pattern) {
+  let regexStr = pattern.replace(/\*\*/g, "%%%DOUBLESTAR%%%").replace(/\*/g, "[^/]*").replace(/%%%DOUBLESTAR%%%/g, ".*").replace(/\./g, "\\.").replace(/\{([^}]+)\}/g, (_, group) => `(${group.split(",").join("|")})`);
+  return new RegExp(`^${regexStr}$`);
+}
+async function detectSchemasInFile(content, _filePath) {
+  const schemas = [];
+  const lines = content.split("\n");
+  for (const pattern of GENERATOR_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const matchText = match[0];
+      const schemaType = match[1];
+      if (!schemaType) continue;
+      const position = match.index;
+      let line = 0;
+      let column = 0;
+      let currentPos = 0;
+      for (let i = 0; i < lines.length; i++) {
+        const currentLine = lines[i];
+        if (!currentLine) continue;
+        if (currentPos + currentLine.length >= position) {
+          line = i + 1;
+          column = position - currentPos;
+          break;
+        }
+        currentPos += currentLine.length + 1;
+      }
+      schemas.push({
+        type: schemaType,
+        generatorFunction: matchText,
+        line,
+        column,
+        issues: []
+        // Se llenarán en la validación
+      });
+    }
+  }
+  return schemas;
+}
+function isRouteFile(filePath, framework) {
+  const normalized = filePath.replace(/\\/g, "/");
+  switch (framework) {
+    case "next":
+      return /\/app\/.*\/page\.(tsx|jsx|ts|js)$/.test(normalized) || /\/pages\/.*\.(tsx|jsx|ts|js)$/.test(normalized);
+    case "nuxt":
+      return /\/pages\/.*\.vue$/.test(normalized);
+    case "astro":
+      return /\/src\/pages\/.*\.astro$/.test(normalized);
+    default:
+      return false;
+  }
+}
+function analyzeRouteFile(_content, filePath, framework) {
+  const normalized = filePath.toLowerCase().replace(/\\/g, "/");
+  let routePath;
+  if (framework === "next") {
+    const appMatch = normalized.match(/\/app\/(.*)\/page\.(tsx|jsx|ts|js)$/);
+    if (appMatch) {
+      routePath = `/${appMatch[1]}`;
+    }
+    const pagesMatch = normalized.match(/\/pages\/(.*)\.(?:tsx|jsx|ts|js)$/);
+    if (pagesMatch) {
+      routePath = `/${pagesMatch[1]}`;
+    }
+  }
+  let suggestedSchemaType;
+  let confidence = 0;
+  let reason;
+  if (/blog|article|post|news/.test(normalized)) {
+    suggestedSchemaType = "Article";
+    confidence = 0.8;
+    reason = "Path contains blog/article/post keywords";
+  } else if (/product|item|shop/.test(normalized)) {
+    suggestedSchemaType = "Product";
+    confidence = 0.75;
+    reason = "Path contains product/shop keywords";
+  } else if (/about|company|contact/.test(normalized)) {
+    suggestedSchemaType = "Organization";
+    confidence = 0.7;
+    reason = "Path suggests organization/company page";
+  } else if (/event|calendar/.test(normalized)) {
+    suggestedSchemaType = "Event";
+    confidence = 0.7;
+    reason = "Path suggests event page";
+  }
+  if (!suggestedSchemaType || confidence < 0.6) {
+    return null;
+  }
+  return {
+    ...routePath && { routePath },
+    suggestedSchemaType,
+    confidence,
+    ...reason && { reason }
+  };
+}
+async function getProjectStats(rootDir = process.cwd()) {
+  const framework = await detectFramework(rootDir);
+  let estimatedFiles = 0;
+  try {
+    const entries = await fs.readdir(rootDir, { withFileTypes: true });
+    estimatedFiles = entries.filter((e) => e.isFile()).length;
+  } catch {
+    estimatedFiles = 0;
+  }
+  let hasPackageJson = false;
+  try {
+    await fs.access(path.join(rootDir, "package.json"));
+    hasPackageJson = true;
+  } catch {
+    hasPackageJson = false;
+  }
+  return {
+    framework,
+    estimatedFiles,
+    hasPackageJson
+  };
+}
+var PostalAddressSchema = z.object({
+  "@type": z.literal("PostalAddress").default("PostalAddress"),
+  streetAddress: z.string().optional(),
+  addressLocality: z.string().optional(),
+  addressRegion: z.string().optional(),
+  postalCode: z.string().optional(),
+  addressCountry: z.string().length(2).optional()
+  // ISO 3166-1 alpha-2
+});
+var ContactPointSchema = z.object({
+  "@type": z.literal("ContactPoint").default("ContactPoint"),
+  telephone: z.string().optional(),
+  email: z.string().email().optional(),
+  contactType: z.enum(["customer service", "technical support", "sales", "billing"]).optional(),
+  areaServed: z.string().optional(),
+  availableLanguage: z.array(z.string()).optional()
+});
+var OrganizationSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.literal("Organization").default("Organization"),
+  // Required fields
+  name: z.string().min(1, "Organization name is required"),
+  url: z.string().url("Must be a valid URL"),
+  // Recommended fields
+  logo: z.string().url("Logo must be a valid URL").optional(),
+  image: z.string().url("Image must be a valid URL").optional(),
+  description: z.string().min(10, "Description should be at least 10 characters").optional(),
+  /**
+   * CRITICAL for GEO: Entity disambiguation
+   * Should include at least one social profile or authority ID (Wikidata, Wikipedia, etc.)
+   */
+  sameAs: z.array(z.string().url()).min(1, "At least one sameAs URL is required for entity disambiguation").describe("Social profiles, Wikidata ID, Wikipedia URL for entity disambiguation"),
+  // Contact information
+  email: z.string().email().optional(),
+  telephone: z.string().optional(),
+  address: PostalAddressSchema.optional(),
+  contactPoint: z.union([ContactPointSchema, z.array(ContactPointSchema)]).optional(),
+  // Additional information
+  alternateName: z.string().optional(),
+  foundingDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Must be in YYYY-MM-DD format").optional(),
+  founder: z.array(z.string()).optional(),
+  // Relationships
+  parentOrganization: z.string().optional(),
+  subOrganization: z.array(z.string()).optional()
+});
+var PersonSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.literal("Person").default("Person"),
+  // Required fields
+  name: z.string().min(1, "Person name is required"),
+  url: z.string().url("Must be a valid URL").optional(),
+  // Recommended fields
+  image: z.string().url("Image must be a valid URL").optional(),
+  description: z.string().min(10, "Description should be at least 10 characters").optional(),
+  /**
+   * CRITICAL for GEO: Entity disambiguation
+   * Should include social profiles, Wikidata ID, Wikipedia URL, etc.
+   */
+  sameAs: z.array(z.string().url()).min(1, "At least one sameAs URL is required for entity disambiguation").describe("Social profiles, Wikidata ID, Wikipedia URL for entity disambiguation"),
+  // Contact information
+  email: z.string().email().optional(),
+  telephone: z.string().optional(),
+  address: PostalAddressSchema.optional(),
+  // Professional information
+  jobTitle: z.string().optional(),
+  worksFor: z.object({
+    "@type": z.literal("Organization"),
+    name: z.string(),
+    url: z.string().url().optional()
+  }).optional(),
+  // Additional information
+  alternateName: z.string().optional(),
+  birthDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Must be in YYYY-MM-DD format").optional(),
+  nationality: z.string().optional(),
+  // Relationships
+  colleague: z.array(z.string()).optional(),
+  alumniOf: z.string().optional()
+});
+var OfferSchema = z.object({
+  "@type": z.literal("Offer").default("Offer"),
+  price: z.union([z.string(), z.number()]),
+  priceCurrency: z.string().length(3),
+  // ISO 4217 currency code
+  availability: z.string().url().optional().describe("e.g., https://schema.org/InStock"),
+  url: z.string().url().optional(),
+  priceValidUntil: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+  seller: z.object({
+    "@type": z.literal("Organization"),
+    name: z.string()
+  }).optional()
+});
+var AggregateRatingSchema = z.object({
+  "@type": z.literal("AggregateRating").default("AggregateRating"),
+  ratingValue: z.union([z.string(), z.number()]),
+  reviewCount: z.number().int().positive(),
+  bestRating: z.union([z.string(), z.number()]).optional().default(5),
+  worstRating: z.union([z.string(), z.number()]).optional().default(1)
+});
+var ReviewSchema = z.object({
+  "@type": z.literal("Review").default("Review"),
+  author: z.object({
+    "@type": z.literal("Person"),
+    name: z.string()
+  }),
+  datePublished: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  reviewBody: z.string().min(10),
+  reviewRating: z.object({
+    "@type": z.literal("Rating"),
+    ratingValue: z.union([z.string(), z.number()]),
+    bestRating: z.union([z.string(), z.number()]).optional().default(5)
+  })
+});
+var ProductSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.literal("Product").default("Product"),
+  // Required fields
+  name: z.string().min(1, "Product name is required"),
+  // Recommended fields
+  image: z.union([z.string().url(), z.array(z.string().url())]).optional(),
+  description: z.string().min(10, "Description should be at least 10 characters").optional(),
+  // SKU or other identifiers
+  sku: z.string().optional(),
+  gtin: z.string().optional(),
+  gtin8: z.string().optional(),
+  gtin12: z.string().optional(),
+  gtin13: z.string().optional(),
+  gtin14: z.string().optional(),
+  mpn: z.string().optional(),
+  // Brand
+  brand: z.object({
+    "@type": z.literal("Brand"),
+    name: z.string()
+  }).optional(),
+  // Offers (pricing)
+  offers: z.union([OfferSchema, z.array(OfferSchema)]).optional(),
+  // Ratings and Reviews
+  aggregateRating: AggregateRatingSchema.optional(),
+  review: z.union([ReviewSchema, z.array(ReviewSchema)]).optional(),
+  // Additional information
+  category: z.string().optional(),
+  color: z.union([z.string(), z.array(z.string())]).optional(),
+  material: z.string().optional(),
+  manufacturer: z.object({
+    "@type": z.literal("Organization"),
+    name: z.string()
+  }).optional()
+});
+var ArticleSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.enum(["Article", "NewsArticle", "BlogPosting", "TechArticle"]).default("Article"),
+  // Required fields
+  headline: z.string().min(1).max(110, "Headline should be less than 110 characters for optimal SEO"),
+  image: z.union([z.string().url(), z.array(z.string().url())]),
+  // Recommended fields
+  author: z.union([
+    z.object({
+      "@type": z.enum(["Person", "Organization"]),
+      name: z.string(),
+      url: z.string().url().optional()
+    }),
+    z.array(
+      z.object({
+        "@type": z.enum(["Person", "Organization"]),
+        name: z.string(),
+        url: z.string().url().optional()
+      })
+    )
+  ]).describe("Author(s) of the article"),
+  datePublished: z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}Z)?$/, "Must be ISO 8601 format"),
+  dateModified: z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}Z)?$/, "Must be ISO 8601 format").optional(),
+  // Publisher (recommended for Google News)
+  publisher: z.object({
+    "@type": z.literal("Organization"),
+    name: z.string(),
+    logo: z.object({
+      "@type": z.literal("ImageObject"),
+      url: z.string().url(),
+      width: z.number().optional(),
+      height: z.number().optional()
+    }).optional()
+  }).optional(),
+  // Content
+  description: z.string().min(10).optional(),
+  articleBody: z.string().min(50, "Article body should be at least 50 characters").optional(),
+  wordCount: z.number().int().positive().optional(),
+  // Additional metadata
+  url: z.string().url().optional(),
+  mainEntityOfPage: z.string().url().optional(),
+  keywords: z.union([z.string(), z.array(z.string())]).optional(),
+  articleSection: z.string().optional(),
+  inLanguage: z.string().optional()
+});
+ArticleSchema.extend({
+  "@type": z.literal("BlogPosting").default("BlogPosting")
+});
+ArticleSchema.extend({
+  "@type": z.literal("NewsArticle").default("NewsArticle"),
+  dateline: z.string().optional()
+});
+var QuestionSchema = z.object({
+  "@type": z.literal("Question").default("Question"),
+  name: z.string().min(1, "Question text is required"),
+  acceptedAnswer: z.object({
+    "@type": z.literal("Answer").default("Answer"),
+    text: z.string().min(1, "Answer text is required")
+  })
+});
+var FAQPageSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.literal("FAQPage").default("FAQPage"),
+  mainEntity: z.array(QuestionSchema).min(1, "At least one question is required for FAQ").describe("Array of questions and answers")
+});
+var ListItemSchema = z.object({
+  "@type": z.literal("ListItem").default("ListItem"),
+  position: z.number().int().positive(),
+  name: z.string().min(1),
+  item: z.string().url().optional()
+});
+var BreadcrumbListSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.literal("BreadcrumbList").default("BreadcrumbList"),
+  itemListElement: z.array(ListItemSchema).min(2, "Breadcrumb list must have at least 2 items").describe("Ordered list of breadcrumb items")
+});
+var WebPageSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.literal("WebPage").default("WebPage"),
+  name: z.string().min(1),
+  description: z.string().min(10).optional(),
+  url: z.string().url(),
+  // Optional fields
+  inLanguage: z.string().optional(),
+  isPartOf: z.object({
+    "@type": z.literal("WebSite"),
+    name: z.string(),
+    url: z.string().url()
+  }).optional(),
+  breadcrumb: z.object({
+    "@type": z.literal("BreadcrumbList")
+  }).optional(),
+  datePublished: z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}Z)?$/).optional(),
+  dateModified: z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}Z)?$/).optional(),
+  author: z.object({
+    "@type": z.enum(["Person", "Organization"]),
+    name: z.string()
+  }).optional()
+});
+z.object({
+  title: z.string().min(1).max(60, "Title should be less than 60 characters for optimal display"),
+  description: z.string().min(1).max(160, "Description should be less than 160 characters"),
+  url: z.string().url(),
+  type: z.enum(["website", "article", "product", "book", "profile", "music", "video"]).default("website"),
+  image: z.string().url(),
+  imageAlt: z.string().optional(),
+  siteName: z.string().optional(),
+  locale: z.string().default("en_US"),
+  // Article-specific
+  publishedTime: z.string().optional(),
+  modifiedTime: z.string().optional(),
+  author: z.string().optional(),
+  section: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  // Product-specific
+  price: z.union([z.string(), z.number()]).optional(),
+  currency: z.string().length(3).optional()
+});
+z.object({
+  card: z.enum(["summary", "summary_large_image", "app", "player"]).default("summary_large_image"),
+  site: z.string().optional(),
+  // @username
+  creator: z.string().optional(),
+  // @username
+  title: z.string().min(1).max(70, "Twitter title should be less than 70 characters"),
+  description: z.string().min(1).max(200, "Twitter description should be less than 200 characters"),
+  image: z.string().url(),
+  imageAlt: z.string().optional()
+});
+var GeoCoordinatesSchema = z.object({
+  "@type": z.literal("GeoCoordinates").default("GeoCoordinates"),
+  latitude: z.number().min(-90).max(90),
+  longitude: z.number().min(-180).max(180)
+});
+var OpeningHoursSchema = z.object({
+  "@type": z.literal("OpeningHoursSpecification").default("OpeningHoursSpecification"),
+  dayOfWeek: z.union([
+    z.enum(["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]),
+    z.array(z.enum(["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]))
+  ]),
+  opens: z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Must be in HH:MM format"),
+  closes: z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Must be in HH:MM format")
+});
+var LocalBusinessSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.string().default("LocalBusiness"),
+  // Can be Restaurant, Store, etc.
+  // Required
+  name: z.string().min(1, "Business name is required"),
+  image: z.union([z.string().url(), z.array(z.string().url())]),
+  address: PostalAddressSchema,
+  // Recommended
+  "@id": z.string().url().optional(),
+  url: z.string().url().optional(),
+  telephone: z.string().optional(),
+  priceRange: z.string().optional(),
+  // e.g., "$$"
+  // Location
+  geo: GeoCoordinatesSchema.optional(),
+  // Opening hours
+  openingHoursSpecification: z.union([
+    OpeningHoursSchema,
+    z.array(OpeningHoursSchema)
+  ]).optional(),
+  // Ratings
+  aggregateRating: z.object({
+    "@type": z.literal("AggregateRating"),
+    ratingValue: z.union([z.string(), z.number()]),
+    reviewCount: z.number().int().positive()
+  }).optional(),
+  // Additional info
+  description: z.string().min(10).optional(),
+  servesCuisine: z.union([z.string(), z.array(z.string())]).optional(),
+  // For restaurants
+  menu: z.string().url().optional(),
+  // For restaurants
+  acceptsReservations: z.union([z.boolean(), z.string()]).optional(),
+  paymentAccepted: z.string().optional()
+});
+var PlaceSchema = z.object({
+  "@type": z.literal("Place").default("Place"),
+  name: z.string(),
+  address: z.union([
+    z.string(),
+    z.object({
+      "@type": z.literal("PostalAddress"),
+      streetAddress: z.string().optional(),
+      addressLocality: z.string().optional(),
+      addressRegion: z.string().optional(),
+      postalCode: z.string().optional(),
+      addressCountry: z.string().optional()
+    })
+  ]).optional()
+});
+var EventOfferSchema = z.object({
+  "@type": z.literal("Offer").default("Offer"),
+  url: z.string().url().optional(),
+  price: z.union([z.string(), z.number()]),
+  priceCurrency: z.string().length(3),
+  availability: z.string().url().optional(),
+  validFrom: z.string().optional()
+});
+var EventSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.enum(["Event", "MusicEvent", "BusinessEvent", "SportsEvent", "TheaterEvent", "EducationEvent"]).default("Event"),
+  // Required
+  name: z.string().min(1, "Event name is required"),
+  startDate: z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2})?$/, "Must be ISO 8601 format"),
+  // Recommended
+  endDate: z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2})?$/, "Must be ISO 8601 format").optional(),
+  eventStatus: z.enum([
+    "https://schema.org/EventScheduled",
+    "https://schema.org/EventCancelled",
+    "https://schema.org/EventMovedOnline",
+    "https://schema.org/EventPostponed",
+    "https://schema.org/EventRescheduled"
+  ]).optional(),
+  eventAttendanceMode: z.enum([
+    "https://schema.org/OfflineEventAttendanceMode",
+    "https://schema.org/OnlineEventAttendanceMode",
+    "https://schema.org/MixedEventAttendanceMode"
+  ]).optional(),
+  location: z.union([PlaceSchema, z.string().url()]).optional(),
+  // Can be Place or VirtualLocation URL
+  image: z.union([z.string().url(), z.array(z.string().url())]).optional(),
+  description: z.string().min(10).optional(),
+  // Organizer
+  organizer: z.object({
+    "@type": z.enum(["Organization", "Person"]),
+    name: z.string(),
+    url: z.string().url().optional()
+  }).optional(),
+  // Performer
+  performer: z.union([
+    z.object({
+      "@type": z.enum(["Person", "PerformingGroup"]),
+      name: z.string()
+    }),
+    z.array(z.object({
+      "@type": z.enum(["Person", "PerformingGroup"]),
+      name: z.string()
+    }))
+  ]).optional(),
+  // Offers (tickets)
+  offers: z.union([EventOfferSchema, z.array(EventOfferSchema)]).optional(),
+  // Additional
+  url: z.string().url().optional()
+});
+
+// src/auditor/schema-validator.ts
+var SCHEMA_VALIDATORS = {
+  Article: ArticleSchema,
+  Product: ProductSchema,
+  Organization: OrganizationSchema,
+  Person: PersonSchema,
+  LocalBusiness: LocalBusinessSchema,
+  Event: EventSchema,
+  WebPage: WebPageSchema,
+  FAQPage: FAQPageSchema,
+  BreadcrumbList: BreadcrumbListSchema
+};
+var REQUIRED_FIELDS = {
+  Article: ["@type", "@context", "headline", "author", "datePublished"],
+  Product: ["@type", "@context", "name"],
+  Organization: ["@type", "@context", "name"],
+  Person: ["@type", "@context", "name"],
+  LocalBusiness: ["@type", "@context", "name", "address"],
+  Event: ["@type", "@context", "name", "startDate", "location"],
+  WebPage: ["@type", "@context", "name"],
+  FAQ: ["@type", "@context", "mainEntity"],
+  Breadcrumb: ["@type", "@context", "itemListElement"]
+};
+var RECOMMENDED_FIELDS = {
+  Article: ["image", "dateModified", "publisher", "description"],
+  Product: ["image", "price", "availability", "brand", "description"],
+  Organization: ["url", "logo", "sameAs", "contactPoint"],
+  Person: ["image", "url", "sameAs", "jobTitle"],
+  LocalBusiness: ["telephone", "geo", "openingHours", "image"],
+  Event: ["description", "image", "organizer", "eventStatus"],
+  WebPage: ["description", "url"],
+  FAQ: [],
+  // FAQ no tiene campos especialmente recomendados adicionales
+  Breadcrumb: []
+  // Breadcrumb es simple
+};
+var DEPRECATED_FIELDS = {
+  Article: ["version"],
+  // 'version' ya no se usa en Article
+  Organization: ["founder"],
+  // Bajo valor semántico para GEO
+  Product: ["model"]
+  // Confuso, mejor usar 'name' o 'mpn'
+};
+async function validateSchemas(scanResult, options = {}) {
+  const fileResults = [];
+  let totalSchemas = 0;
+  let validSchemas = 0;
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  for (const file of scanResult.filesWithSchemas) {
+    const schemasToValidate = options.schemaTypes ? file.schemas.filter((s) => options.schemaTypes.includes(s.type)) : file.schemas;
+    const fileIssues = [];
+    for (const schema of schemasToValidate) {
+      totalSchemas++;
+      const issues = validateSchema(schema);
+      schema.issues = issues;
+      const errors = issues.filter((i) => i.severity === "error").length;
+      const warnings = issues.filter((i) => i.severity === "warning").length;
+      totalErrors += errors;
+      totalWarnings += warnings;
+      if (errors === 0) {
+        validSchemas++;
+      }
+      fileIssues.push(...issues);
+    }
+    const fileValid = fileIssues.filter((i) => i.severity === "error").length === 0 && (!options.strict || fileIssues.filter((i) => i.severity === "warning").length === 0);
+    fileResults.push({
+      filePath: file.filePath,
+      valid: fileValid,
+      schemas: schemasToValidate,
+      issues: fileIssues
+    });
+  }
+  const commonIssues = generateCommonIssues(fileResults);
+  const valid = totalErrors === 0 && (!options.strict || totalWarnings === 0);
+  return {
+    valid,
+    totalSchemas,
+    validSchemas,
+    errors: totalErrors,
+    warnings: totalWarnings,
+    fileResults,
+    commonIssues
+  };
+}
+function validateSchema(schema) {
+  const issues = [];
+  const schemaType = schema.type;
+  if (!schema.schema) {
+    issues.push({
+      severity: "info",
+      message: `Could not parse schema for deep validation. Using '${schema.generatorFunction}' at line ${schema.line}.`
+    });
+    return issues;
+  }
+  const data = schema.schema;
+  const requiredFields = REQUIRED_FIELDS[schemaType] || [];
+  for (const field of requiredFields) {
+    if (!hasField(data, field)) {
+      const autoFix = generateAutoFix(field, schemaType);
+      issues.push({
+        severity: "error",
+        field,
+        message: `Required field '${field}' is missing`,
+        fix: `Add '${field}' field to your ${schemaType} schema`,
+        ...autoFix && { autoFixCode: autoFix }
+      });
+    }
+  }
+  const recommendedFields = RECOMMENDED_FIELDS[schemaType] || [];
+  for (const field of recommendedFields) {
+    if (!hasField(data, field)) {
+      issues.push({
+        severity: "warning",
+        field,
+        message: `Recommended field '${field}' is missing`,
+        fix: `Consider adding '${field}' for better SEO and GEO`
+      });
+    }
+  }
+  const deprecatedFields = DEPRECATED_FIELDS[schemaType] || [];
+  for (const field of deprecatedFields) {
+    if (hasField(data, field)) {
+      issues.push({
+        severity: "info",
+        field,
+        message: `Field '${field}' is deprecated or has low semantic value`,
+        fix: `Consider removing '${field}' to reduce token usage`
+      });
+    }
+  }
+  const validator = SCHEMA_VALIDATORS[schemaType];
+  if (validator) {
+    try {
+      validator.parse(data);
+    } catch (error) {
+      if (error.errors) {
+        for (const zodError of error.errors) {
+          issues.push({
+            severity: "error",
+            field: zodError.path.join("."),
+            message: zodError.message,
+            fix: `Fix type or format of '${zodError.path.join(".")}'`
+          });
+        }
+      }
+    }
+  }
+  issues.push(...validateSchemaSpecificRules(schemaType, data));
+  return issues;
+}
+function validateSchemaSpecificRules(schemaType, data) {
+  const issues = [];
+  switch (schemaType) {
+    case "Article":
+      if (data.datePublished && data.dateModified) {
+        const published = new Date(data.datePublished);
+        const modified = new Date(data.dateModified);
+        if (published > modified) {
+          issues.push({
+            severity: "error",
+            field: "dateModified",
+            message: "dateModified must be after datePublished",
+            fix: "Ensure dateModified is later than datePublished"
+          });
+        }
+      }
+      if (data.wordCount && (data.wordCount < 100 || data.wordCount > 1e4)) {
+        issues.push({
+          severity: "warning",
+          field: "wordCount",
+          message: `wordCount seems unusual: ${data.wordCount}`,
+          fix: "Verify wordCount is calculated correctly"
+        });
+      }
+      break;
+    case "Product":
+      if (data.price && !data.priceCurrency) {
+        issues.push({
+          severity: "error",
+          field: "priceCurrency",
+          message: "priceCurrency is required when price is specified",
+          fix: 'Add priceCurrency (e.g., "USD", "EUR")'
+        });
+      }
+      if (data.availability) {
+        const validAvailability = [
+          "InStock",
+          "OutOfStock",
+          "PreOrder",
+          "Discontinued",
+          "SoldOut"
+        ];
+        if (!validAvailability.includes(data.availability)) {
+          issues.push({
+            severity: "warning",
+            field: "availability",
+            message: `availability value '${data.availability}' is not standard`,
+            fix: `Use one of: ${validAvailability.join(", ")}`
+          });
+        }
+      }
+      break;
+    case "Organization":
+    case "LocalBusiness":
+      if (data.logo && typeof data.logo === "string") {
+        if (!data.logo.startsWith("https://")) {
+          issues.push({
+            severity: "warning",
+            field: "logo",
+            message: "Logo URL should use HTTPS",
+            fix: "Change logo URL to HTTPS"
+          });
+        }
+      }
+      if (data.telephone && typeof data.telephone === "string") {
+        if (!/^\+?[\d\s\-()]+$/.test(data.telephone)) {
+          issues.push({
+            severity: "info",
+            field: "telephone",
+            message: "Telephone format may not be standard",
+            fix: "Use international format (e.g., +1-555-1234)"
+          });
+        }
+      }
+      break;
+    case "Event":
+      if (data.startDate && data.endDate) {
+        const start = new Date(data.startDate);
+        const end = new Date(data.endDate);
+        if (start > end) {
+          issues.push({
+            severity: "error",
+            field: "endDate",
+            message: "endDate must be after startDate",
+            fix: "Ensure endDate is later than startDate"
+          });
+        }
+      }
+      break;
+  }
+  return issues;
+}
+function hasField(obj, fieldPath) {
+  const parts = fieldPath.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (!current || typeof current !== "object" || !(part in current)) {
+      return false;
+    }
+    current = current[part];
+  }
+  return current !== void 0 && current !== null;
+}
+function generateAutoFix(field, schemaType) {
+  const fixes = {
+    "@context": '"@context": "https://schema.org"',
+    "@type": `"@type": "${schemaType}"`,
+    headline: '"headline": "Your article title"',
+    author: '"author": "Author Name"',
+    datePublished: `"datePublished": new Date().toISOString()`,
+    name: '"name": "Item name"'
+  };
+  return fixes[field];
+}
+function generateCommonIssues(fileResults) {
+  const issueMap = /* @__PURE__ */ new Map();
+  for (const fileResult of fileResults) {
+    for (const issue of fileResult.issues) {
+      const key = `${issue.severity}:${issue.message}`;
+      if (issueMap.has(key)) {
+        const existing = issueMap.get(key);
+        existing.count++;
+        if (!existing.affectedFiles.includes(fileResult.filePath)) {
+          existing.affectedFiles.push(fileResult.filePath);
+        }
+      } else {
+        issueMap.set(key, {
+          type: issue.message,
+          count: 1,
+          severity: issue.severity,
+          affectedFiles: [fileResult.filePath]
+        });
+      }
+    }
+  }
+  return Array.from(issueMap.values()).sort((a, b) => b.count - a.count);
+}
+function validateSingleSchema(schemaType, schemaData) {
+  const foundSchema = {
+    type: schemaType,
+    generatorFunction: "manual",
+    line: 0,
+    schema: schemaData};
+  return validateSchema(foundSchema);
+}
+function generateCoverageReport(scanResult, validationResult, optimizations = []) {
+  const totalFiles = scanResult.filesScanned;
+  const filesWithSchemas = scanResult.filesWithSchemas.length;
+  const routesWithoutSchemas = scanResult.routesWithoutSchemas.length;
+  const totalSchemas = validationResult.totalSchemas;
+  const totalRoutes = filesWithSchemas + routesWithoutSchemas;
+  const coverage = totalRoutes > 0 ? filesWithSchemas / totalRoutes * 100 : 0;
+  const schemasByType = {};
+  for (const file of scanResult.filesWithSchemas) {
+    for (const schema of file.schemas) {
+      schemasByType[schema.type] = (schemasByType[schema.type] || 0) + 1;
+    }
+  }
+  const score = calculateProjectScore(scanResult, validationResult, coverage);
+  const allIssues = validationResult.fileResults.flatMap((f) => f.issues);
+  return {
+    project: {
+      root: scanResult.projectRoot,
+      ...scanResult.framework && { framework: scanResult.framework },
+      scannedAt: scanResult.scannedAt
+    },
+    stats: {
+      totalFiles,
+      filesWithSchemas,
+      routesWithoutSchemas,
+      totalSchemas,
+      coverage: Math.round(coverage)
+    },
+    schemasByType,
+    score,
+    files: scanResult.filesWithSchemas,
+    missingSchemas: scanResult.routesWithoutSchemas,
+    issues: allIssues,
+    optimizations
+  };
+}
+function calculateProjectScore(_scanResult, validationResult, coverage) {
+  const presenceScore = coverage;
+  const totalSchemas = validationResult.totalSchemas;
+  const validSchemas = validationResult.validSchemas;
+  const validityScore = totalSchemas > 0 ? validSchemas / totalSchemas * 100 : 0;
+  const totalWarnings = validationResult.warnings;
+  const maxExpectedWarnings = totalSchemas * 2;
+  const completenessScore = Math.max(
+    0,
+    100 - totalWarnings / Math.max(1, maxExpectedWarnings) * 100
+  );
+  const infoIssues = validationResult.fileResults.flatMap(
+    (f) => f.issues.filter((i) => i.severity === "info")
+  ).length;
+  const optimizationScore = Math.max(0, 100 - infoIssues * 10);
+  const total = Math.round(
+    presenceScore * 0.25 + validityScore * 0.35 + completenessScore * 0.25 + optimizationScore * 0.15
+  );
+  return {
+    total: Math.min(100, Math.max(0, total)),
+    breakdown: {
+      presence: Math.round(presenceScore),
+      validity: Math.round(validityScore),
+      completeness: Math.round(completenessScore),
+      optimization: Math.round(optimizationScore)
+    }
+  };
+}
+async function saveReport(report, options = {}) {
+  const format = options.format || "json";
+  let content;
+  switch (format) {
+    case "json":
+      content = generateJSONReport(report);
+      break;
+    case "html":
+      content = generateHTMLReport(report);
+      break;
+    case "markdown":
+      content = generateMarkdownReport(report);
+      break;
+    default:
+      throw new Error(`Unknown format: ${format}`);
+  }
+  if (options.output) {
+    await fs.writeFile(options.output, content, "utf-8");
+  } else {
+    console.log(content);
+  }
+}
+function generateJSONReport(report) {
+  return JSON.stringify(report, null, 2);
+}
+function generateMarkdownReport(report) {
+  const { project, stats, score, schemasByType, issues, missingSchemas } = report;
+  let md = `# JSON-LD Audit Report
+
+`;
+  md += `**Project:** ${project.root}
+`;
+  md += `**Framework:** ${project.framework || "Unknown"}
+`;
+  md += `**Date:** ${new Date(project.scannedAt).toLocaleString()}
+
+`;
+  md += `## Score: ${score.total}/100
+
+`;
+  md += `- **Presence:** ${score.breakdown.presence}/100 (${stats.coverage}% coverage)
+`;
+  md += `- **Validity:** ${score.breakdown.validity}/100
+`;
+  md += `- **Completeness:** ${score.breakdown.completeness}/100
+`;
+  md += `- **Optimization:** ${score.breakdown.optimization}/100
+
+`;
+  md += `## Statistics
+
+`;
+  md += `- Total files scanned: ${stats.totalFiles}
+`;
+  md += `- Files with schemas: ${stats.filesWithSchemas}
+`;
+  md += `- Routes without schemas: ${stats.routesWithoutSchemas}
+`;
+  md += `- Total schemas: ${stats.totalSchemas}
+
+`;
+  md += `## Schemas by Type
+
+`;
+  for (const [type, count] of Object.entries(schemasByType)) {
+    md += `- **${type}**: ${count}
+`;
+  }
+  md += `
+`;
+  if (issues.length > 0) {
+    md += `## Issues Found
+
+`;
+    const errors = issues.filter((i) => i.severity === "error");
+    const warnings = issues.filter((i) => i.severity === "warning");
+    if (errors.length > 0) {
+      md += `### Errors (${errors.length})
+
+`;
+      errors.slice(0, 10).forEach((issue) => {
+        md += `- **${issue.field || "General"}**: ${issue.message}
+`;
+        if (issue.fix) md += `  - Fix: ${issue.fix}
+`;
+      });
+      if (errors.length > 10) {
+        md += `
+... and ${errors.length - 10} more errors
+`;
+      }
+      md += `
+`;
+    }
+    if (warnings.length > 0) {
+      md += `### Warnings (${warnings.length})
+
+`;
+      warnings.slice(0, 10).forEach((issue) => {
+        md += `- **${issue.field || "General"}**: ${issue.message}
+`;
+        if (issue.fix) md += `  - Suggestion: ${issue.fix}
+`;
+      });
+      if (warnings.length > 10) {
+        md += `
+... and ${warnings.length - 10} more warnings
+`;
+      }
+      md += `
+`;
+    }
+  }
+  if (missingSchemas.length > 0) {
+    md += `## Missing Schemas
+
+`;
+    md += `Routes that should have schemas but don't:
+
+`;
+    missingSchemas.slice(0, 10).forEach((route) => {
+      md += `- **${route.filePath}**`;
+      if (route.suggestedSchemaType) {
+        md += ` \u2192 Suggested: ${route.suggestedSchemaType}`;
+      }
+      md += `
+`;
+    });
+    if (missingSchemas.length > 10) {
+      md += `
+... and ${missingSchemas.length - 10} more routes
+`;
+    }
+    md += `
+`;
+  }
+  md += `---
+
+`;
+  md += `Generated by [geo-semantic-layer](https://www.npmjs.com/package/geo-semantic-layer)
+`;
+  return md;
+}
+function generateHTMLReport(report) {
+  const { project, stats, score, schemasByType, issues, missingSchemas } = report;
+  const errors = issues.filter((i) => i.severity === "error");
+  const warnings = issues.filter((i) => i.severity === "warning");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>JSON-LD Audit Report</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      line-height: 1.6;
+      color: #333;
+      background: #f5f5f5;
+      padding: 20px;
+    }
+    .container {
+      max-width: 1200px;
+      margin: 0 auto;
+      background: white;
+      border-radius: 8px;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+      overflow: hidden;
+    }
+    header {
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: white;
+      padding: 30px;
+    }
+    h1 { font-size: 32px; margin-bottom: 10px; }
+    .meta { opacity: 0.9; font-size: 14px; }
+    .score-section {
+      padding: 30px;
+      background: #f9fafb;
+      border-bottom: 1px solid #e5e7eb;
+    }
+    .score-card {
+      display: flex;
+      align-items: center;
+      gap: 30px;
+    }
+    .score-circle {
+      width: 120px;
+      height: 120px;
+      border-radius: 50%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 36px;
+      font-weight: bold;
+      color: white;
+      flex-shrink: 0;
+    }
+    .score-excellent { background: #10b981; }
+    .score-good { background: #3b82f6; }
+    .score-warning { background: #f59e0b; }
+    .score-poor { background: #ef4444; }
+    .score-breakdown {
+      flex: 1;
+      display: grid;
+      grid-template-columns: repeat(2, 1fr);
+      gap: 15px;
+    }
+    .score-item {
+      background: white;
+      padding: 15px;
+      border-radius: 6px;
+      border-left: 4px solid #667eea;
+    }
+    .score-item h3 { font-size: 14px; color: #6b7280; margin-bottom: 5px; }
+    .score-item .value { font-size: 24px; font-weight: bold; color: #111827; }
+    .stats-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+      gap: 20px;
+      padding: 30px;
+    }
+    .stat-card {
+      background: #f9fafb;
+      padding: 20px;
+      border-radius: 8px;
+      border: 1px solid #e5e7eb;
+    }
+    .stat-card h3 { font-size: 14px; color: #6b7280; margin-bottom: 10px; }
+    .stat-card .value { font-size: 32px; font-weight: bold; color: #111827; }
+    .section {
+      padding: 30px;
+      border-bottom: 1px solid #e5e7eb;
+    }
+    .section h2 {
+      font-size: 20px;
+      margin-bottom: 20px;
+      color: #111827;
+    }
+    .issue-list {
+      display: flex;
+      flex-direction: column;
+      gap: 12px;
+    }
+    .issue {
+      padding: 15px;
+      border-radius: 6px;
+      border-left: 4px solid;
+    }
+    .issue-error {
+      background: #fef2f2;
+      border-left-color: #ef4444;
+    }
+    .issue-warning {
+      background: #fffbeb;
+      border-left-color: #f59e0b;
+    }
+    .issue-info {
+      background: #eff6ff;
+      border-left-color: #3b82f6;
+    }
+    .issue-header {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+      margin-bottom: 8px;
+    }
+    .issue-badge {
+      padding: 4px 8px;
+      border-radius: 4px;
+      font-size: 11px;
+      font-weight: 600;
+      text-transform: uppercase;
+    }
+    .badge-error { background: #ef4444; color: white; }
+    .badge-warning { background: #f59e0b; color: white; }
+    .badge-info { background: #3b82f6; color: white; }
+    .issue-field {
+      font-family: 'Courier New', monospace;
+      font-size: 13px;
+      color: #6b7280;
+    }
+    .issue-message { font-size: 14px; color: #111827; margin-bottom: 6px; }
+    .issue-fix {
+      font-size: 13px;
+      color: #059669;
+      font-style: italic;
+    }
+    .file-list {
+      display: flex;
+      flex-direction: column;
+      gap: 10px;
+    }
+    .file-item {
+      padding: 12px;
+      background: #f9fafb;
+      border-radius: 6px;
+      border: 1px solid #e5e7eb;
+      font-family: 'Courier New', monospace;
+      font-size: 13px;
+    }
+    .schema-type {
+      display: inline-block;
+      padding: 2px 8px;
+      background: #667eea;
+      color: white;
+      border-radius: 4px;
+      font-size: 11px;
+      margin-left: 8px;
+    }
+    footer {
+      padding: 20px 30px;
+      background: #f9fafb;
+      text-align: center;
+      color: #6b7280;
+      font-size: 14px;
+    }
+    .chart {
+      width: 100%;
+      max-width: 400px;
+      margin: 0 auto;
+    }
+    .chart-bar {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+      margin-bottom: 12px;
+    }
+    .chart-label {
+      width: 100px;
+      text-align: right;
+      font-size: 14px;
+      color: #6b7280;
+    }
+    .chart-track {
+      flex: 1;
+      height: 24px;
+      background: #e5e7eb;
+      border-radius: 4px;
+      overflow: hidden;
+    }
+    .chart-fill {
+      height: 100%;
+      background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+      transition: width 0.3s ease;
+    }
+    .chart-value {
+      width: 40px;
+      text-align: right;
+      font-weight: bold;
+      font-size: 14px;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <header>
+      <h1>\u{1F4CA} JSON-LD Audit Report</h1>
+      <div class="meta">
+        <strong>Project:</strong> ${project.root}<br>
+        <strong>Framework:</strong> ${project.framework || "Unknown"}<br>
+        <strong>Date:</strong> ${new Date(project.scannedAt).toLocaleString()}
+      </div>
+    </header>
+
+    <div class="score-section">
+      <div class="score-card">
+        <div class="score-circle ${getScoreClass(score.total)}">
+          ${score.total}
+        </div>
+        <div class="score-breakdown">
+          <div class="score-item">
+            <h3>Presence</h3>
+            <div class="value">${score.breakdown.presence}/100</div>
+          </div>
+          <div class="score-item">
+            <h3>Validity</h3>
+            <div class="value">${score.breakdown.validity}/100</div>
+          </div>
+          <div class="score-item">
+            <h3>Completeness</h3>
+            <div class="value">${score.breakdown.completeness}/100</div>
+          </div>
+          <div class="score-item">
+            <h3>Optimization</h3>
+            <div class="value">${score.breakdown.optimization}/100</div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <div class="stats-grid">
+      <div class="stat-card">
+        <h3>Files Scanned</h3>
+        <div class="value">${stats.totalFiles}</div>
+      </div>
+      <div class="stat-card">
+        <h3>With Schemas</h3>
+        <div class="value">${stats.filesWithSchemas}</div>
+      </div>
+      <div class="stat-card">
+        <h3>Coverage</h3>
+        <div class="value">${stats.coverage}%</div>
+      </div>
+      <div class="stat-card">
+        <h3>Total Schemas</h3>
+        <div class="value">${stats.totalSchemas}</div>
+      </div>
+    </div>
+
+    <div class="section">
+      <h2>Schemas by Type</h2>
+      <div class="chart">
+        ${Object.entries(schemasByType).map(
+    ([type, count]) => `
+          <div class="chart-bar">
+            <div class="chart-label">${type}</div>
+            <div class="chart-track">
+              <div class="chart-fill" style="width: ${count / Math.max(...Object.values(schemasByType)) * 100}%"></div>
+            </div>
+            <div class="chart-value">${count}</div>
+          </div>
+        `
+  ).join("")}
+      </div>
+    </div>
+
+    ${errors.length > 0 ? `
+    <div class="section">
+      <h2>\u274C Errors (${errors.length})</h2>
+      <div class="issue-list">
+        ${errors.slice(0, 20).map(
+    (issue) => `
+          <div class="issue issue-error">
+            <div class="issue-header">
+              <span class="issue-badge badge-error">Error</span>
+              ${issue.field ? `<span class="issue-field">${issue.field}</span>` : ""}
+            </div>
+            <div class="issue-message">${issue.message}</div>
+            ${issue.fix ? `<div class="issue-fix">\u{1F4A1} ${issue.fix}</div>` : ""}
+          </div>
+        `
+  ).join("")}
+        ${errors.length > 20 ? `<div class="file-item">... and ${errors.length - 20} more errors</div>` : ""}
+      </div>
+    </div>
+    ` : ""}
+
+    ${warnings.length > 0 ? `
+    <div class="section">
+      <h2>\u26A0\uFE0F  Warnings (${warnings.length})</h2>
+      <div class="issue-list">
+        ${warnings.slice(0, 20).map(
+    (issue) => `
+          <div class="issue issue-warning">
+            <div class="issue-header">
+              <span class="issue-badge badge-warning">Warning</span>
+              ${issue.field ? `<span class="issue-field">${issue.field}</span>` : ""}
+            </div>
+            <div class="issue-message">${issue.message}</div>
+            ${issue.fix ? `<div class="issue-fix">\u{1F4A1} ${issue.fix}</div>` : ""}
+          </div>
+        `
+  ).join("")}
+        ${warnings.length > 20 ? `<div class="file-item">... and ${warnings.length - 20} more warnings</div>` : ""}
+      </div>
+    </div>
+    ` : ""}
+
+    ${missingSchemas.length > 0 ? `
+    <div class="section">
+      <h2>\u{1F4C4} Routes Without Schemas (${missingSchemas.length})</h2>
+      <div class="file-list">
+        ${missingSchemas.slice(0, 20).map(
+    (route) => `
+          <div class="file-item">
+            ${route.filePath}
+            ${route.suggestedSchemaType ? `<span class="schema-type">${route.suggestedSchemaType}</span>` : ""}
+            ${route.reason ? `<br><small style="color: #6b7280;">${route.reason}</small>` : ""}
+          </div>
+        `
+  ).join("")}
+        ${missingSchemas.length > 20 ? `<div class="file-item">... and ${missingSchemas.length - 20} more routes</div>` : ""}
+      </div>
+    </div>
+    ` : ""}
+
+    <footer>
+      Generated by <strong>geo-semantic-layer</strong> &middot; <a href="https://www.npmjs.com/package/geo-semantic-layer" target="_blank">npm</a>
+    </footer>
+  </div>
+</body>
+</html>`;
+}
+function getScoreClass(score) {
+  if (score >= 90) return "score-excellent";
+  if (score >= 70) return "score-good";
+  if (score >= 50) return "score-warning";
+  return "score-poor";
+}
+
+// src/optimizer/llm-profiles.ts
+var LLM_PROFILES = {
+  "gpt-4": {
+    model: "gpt-4",
+    tokensPerChar: 0.25,
+    // ~4 chars per token (average for English)
+    maxContextTokens: 8192,
+    recommendedMaxTokens: 500,
+    supportsFunctionCalling: true
+  },
+  "gpt-4-turbo": {
+    model: "gpt-4-turbo",
+    tokensPerChar: 0.25,
+    maxContextTokens: 128e3,
+    recommendedMaxTokens: 1e3,
+    supportsFunctionCalling: true
+  },
+  "gpt-3.5-turbo": {
+    model: "gpt-3.5-turbo",
+    tokensPerChar: 0.25,
+    maxContextTokens: 16385,
+    recommendedMaxTokens: 400,
+    supportsFunctionCalling: true
+  },
+  "claude-3-opus": {
+    model: "claude-3-opus",
+    tokensPerChar: 0.27,
+    // Slightly more efficient tokenization
+    maxContextTokens: 2e5,
+    recommendedMaxTokens: 1e3,
+    supportsFunctionCalling: true
+  },
+  "claude-3-sonnet": {
+    model: "claude-3-sonnet",
+    tokensPerChar: 0.27,
+    maxContextTokens: 2e5,
+    recommendedMaxTokens: 800,
+    supportsFunctionCalling: true
+  },
+  "claude-3-haiku": {
+    model: "claude-3-haiku",
+    tokensPerChar: 0.27,
+    maxContextTokens: 2e5,
+    recommendedMaxTokens: 600,
+    supportsFunctionCalling: true
+  },
+  "claude-2": {
+    model: "claude-2",
+    tokensPerChar: 0.27,
+    maxContextTokens: 1e5,
+    recommendedMaxTokens: 600,
+    supportsFunctionCalling: false
+  },
+  "gemini-pro": {
+    model: "gemini-pro",
+    tokensPerChar: 0.26,
+    maxContextTokens: 32760,
+    recommendedMaxTokens: 600,
+    supportsFunctionCalling: true
+  },
+  "gemini-ultra": {
+    model: "gemini-ultra",
+    tokensPerChar: 0.26,
+    maxContextTokens: 32760,
+    recommendedMaxTokens: 800,
+    supportsFunctionCalling: true
+  }
+};
+function getModelProfile(model) {
+  return LLM_PROFILES[model];
+}
+
+// src/optimizer/token-analyzer.ts
+function analyzeTokenUsage(schema, model) {
+  const serialized = JSON.stringify(schema, null, 2);
+  const totalTokens = estimateTokens(serialized, model);
+  const byField = calculateTokensByField(schema, model);
+  const recommendations = generateRecommendations(totalTokens, byField, model);
+  return {
+    totalTokens,
+    byField,
+    recommendations,
+    model
+  };
+}
+function estimateTokens(text, model) {
+  if (model.startsWith("gpt-")) {
+    try {
+      return encode(text).length;
+    } catch (e) {
+      return approximateTokens(text, model);
+    }
+  }
+  return approximateTokens(text, model);
+}
+function approximateTokens(text, model) {
+  const profile = getModelProfile(model);
+  return Math.ceil(text.length * profile.tokensPerChar);
+}
+function calculateTokensByField(schema, model, path2 = "") {
+  const result = {};
+  if (schema === null || schema === void 0) {
+    return result;
+  }
+  if (typeof schema !== "object") {
+    const serialized = JSON.stringify(schema);
+    const tokens = estimateTokens(serialized, model);
+    result[path2 || "value"] = tokens;
+    return result;
+  }
+  if (Array.isArray(schema)) {
+    schema.forEach((item, index) => {
+      const itemPath = path2 ? `${path2}[${index}]` : `[${index}]`;
+      const itemTokens = calculateTokensByField(item, model, itemPath);
+      Object.assign(result, itemTokens);
+    });
+    return result;
+  }
+  for (const [key, value] of Object.entries(schema)) {
+    const fieldPath = path2 ? `${path2}.${key}` : key;
+    const keyTokens = estimateTokens(`"${key}":`, model);
+    result[`${fieldPath}#key`] = keyTokens;
+    const valueTokens = calculateTokensByField(value, model, fieldPath);
+    Object.assign(result, valueTokens);
+  }
+  return result;
+}
+function generateRecommendations(totalTokens, byField, model) {
+  const recommendations = [];
+  const profile = getModelProfile(model);
+  if (totalTokens > profile.recommendedMaxTokens) {
+    const excess = totalTokens - profile.recommendedMaxTokens;
+    const reduction = (excess / totalTokens * 100).toFixed(1);
+    recommendations.push(
+      `Schema uses ${totalTokens} tokens, ${excess} over recommended ${profile.recommendedMaxTokens} for ${model}. Consider reducing by ${reduction}%.`
+    );
+  }
+  const sortedFields = Object.entries(byField).filter(([key]) => !key.endsWith("#key")).sort(([, a], [, b]) => b - a).slice(0, 5);
+  const topField = sortedFields[0];
+  if (topField && topField[1] > totalTokens * 0.2) {
+    recommendations.push(
+      `Most expensive field: "${topField[0]}" (${topField[1]} tokens, ${(topField[1] / totalTokens * 100).toFixed(1)}% of total)`
+    );
+  }
+  for (const [field, tokens] of Object.entries(byField)) {
+    if (!field.endsWith("#key") && tokens > 100) {
+      recommendations.push(`Consider shortening field "${field}" (${tokens} tokens)`);
+    }
+  }
+  const arrayFields = Object.keys(byField).filter((key) => key.includes("[") && !key.endsWith("#key"));
+  if (arrayFields.length > 10) {
+    recommendations.push(`Schema contains ${arrayFields.length} array items. Consider limiting array sizes.`);
+  }
+  return recommendations;
+}
+
+// src/optimizer/semantic-scorer.ts
+var DEFAULT_SEMANTIC_WEIGHTS = {
+  coreIdentity: 1,
+  seoCritical: 0.85,
+  authorship: 0.75,
+  relationships: 0.6,
+  decorative: 0.2
+};
+var FIELD_IMPORTANCE = {
+  // Core Identity (CRITICAL - never remove)
+  "@context": 1,
+  "@type": 1,
+  name: 1,
+  url: 0.95,
+  // SEO Critical
+  headline: 0.9,
+  description: 0.85,
+  title: 0.85,
+  image: 0.8,
+  // Authorship & Provenance
+  author: 0.8,
+  datePublished: 0.75,
+  publisher: 0.75,
+  dateModified: 0.7,
+  // Content
+  articleBody: 0.7,
+  text: 0.7,
+  about: 0.65,
+  // Products
+  price: 0.85,
+  priceCurrency: 0.8,
+  offers: 0.85,
+  availability: 0.75,
+  brand: 0.7,
+  sku: 0.6,
+  gtin: 0.55,
+  // Relationships (good for context)
+  sameAs: 0.6,
+  isPartOf: 0.55,
+  mainEntity: 0.6,
+  mainEntityOfPage: 0.55,
+  // Navigation
+  breadcrumb: 0.65,
+  itemListElement: 0.6,
+  position: 0.5,
+  // Medium importance
+  keywords: 0.5,
+  inLanguage: 0.5,
+  wordCount: 0.45,
+  commentCount: 0.4,
+  // Low importance (decorative/verbose)
+  alternateName: 0.3,
+  disambiguatingDescription: 0.25,
+  identifier: 0.2,
+  potentialAction: 0.15,
+  // Very low importance
+  interactionStatistic: 0.1,
+  subjectOf: 0.1
+};
+function scoreFields(schema, tokensByField, weights = DEFAULT_SEMANTIC_WEIGHTS) {
+  const scores = {};
+  function traverse(obj, path2 = "") {
+    if (obj === null || obj === void 0 || typeof obj !== "object") {
+      return;
+    }
+    if (Array.isArray(obj)) {
+      obj.forEach((item, index) => {
+        traverse(item, path2 ? `${path2}[${index}]` : `[${index}]`);
+      });
+      return;
+    }
+    for (const [key, value] of Object.entries(obj)) {
+      const fieldPath = path2 ? `${path2}.${key}` : key;
+      const tokenCost = tokensByField[fieldPath] || 0;
+      const semanticValue = calculateSemanticValue(key, value);
+      const efficiency = tokenCost > 0 ? semanticValue / tokenCost : 0;
+      const { recommendation, reason } = determineRecommendation(
+        semanticValue,
+        efficiency,
+        tokenCost
+      );
+      scores[fieldPath] = {
+        semanticValue,
+        tokenCost,
+        efficiency,
+        recommendation,
+        ...reason && { reason }
+      };
+      if (typeof value === "object" && value !== null) {
+        traverse(value, fieldPath);
+      }
+    }
+  }
+  traverse(schema);
+  return scores;
+}
+function calculateSemanticValue(fieldName, value, _weights) {
+  const baseImportance = FIELD_IMPORTANCE[fieldName] || 0.5;
+  let adjustedValue = baseImportance;
+  if (typeof value === "string" && value.length > 500) {
+    adjustedValue *= 0.7;
+  }
+  if (Array.isArray(value) && value.length > 10) {
+    adjustedValue *= 0.8;
+  }
+  if (typeof value === "string" && value.length > 10 && value.length < 200) {
+    adjustedValue *= 1.1;
+  }
+  return Math.min(adjustedValue, 1);
+}
+function determineRecommendation(semanticValue, efficiency, tokenCost) {
+  if (semanticValue >= 0.9) {
+    return { recommendation: "keep", reason: "Critical for schema validity" };
+  }
+  if (semanticValue < 0.3) {
+    return { recommendation: "remove", reason: "Low semantic value" };
+  }
+  if (efficiency < 0.01 && tokenCost > 50) {
+    return { recommendation: "remove", reason: "Inefficient (high cost, low value)" };
+  }
+  if (efficiency > 0.05) {
+    return { recommendation: "keep", reason: "High efficiency" };
+  }
+  return { recommendation: "optional", reason: "Medium value/cost ratio" };
+}
+
+// src/auditor/optimizer-suggestions.ts
+async function generateOptimizationSuggestions(scanResult, targetModel = "gpt-4") {
+  const suggestions = [];
+  for (const file of scanResult.filesWithSchemas) {
+    for (const schema of file.schemas) {
+      if (!schema.schema) continue;
+      const schemaSuggestions = await analyzeSchemaOptimization(
+        file.filePath,
+        schema.type,
+        schema.schema,
+        targetModel
+      );
+      suggestions.push(...schemaSuggestions);
+    }
+  }
+  suggestions.sort((a, b) => {
+    const reductionA = a.impact.reduction || 0;
+    const reductionB = b.impact.reduction || 0;
+    return reductionB - reductionA;
+  });
+  return suggestions;
+}
+async function analyzeSchemaOptimization(filePath, schemaType, schemaData, targetModel) {
+  const suggestions = [];
+  try {
+    const tokenAnalysis = analyzeTokenUsage(schemaData, targetModel);
+    const totalTokens = tokenAnalysis.totalTokens;
+    if (totalTokens > 800) {
+      suggestions.push({
+        filePath,
+        schemaType,
+        type: "token-reduction",
+        message: `Schema is large (${totalTokens} tokens). Consider optimizing for LLM consumption.`,
+        impact: {
+          tokensBefore: totalTokens,
+          tokensAfter: Math.round(totalTokens * 0.6),
+          // Estimación conservadora
+          reduction: 40
+        }
+      });
+    }
+    const fieldScores = scoreFields(schemaData, tokenAnalysis.byField);
+    const lowValueFields = [];
+    for (const [field, score] of Object.entries(fieldScores)) {
+      if (score.semanticValue < 0.4 && score.tokenCost > 20) {
+        lowValueFields.push(field);
+      }
+    }
+    if (lowValueFields.length > 0) {
+      const tokenSavings = lowValueFields.reduce(
+        (sum, field) => {
+          var _a;
+          return sum + (((_a = fieldScores[field]) == null ? void 0 : _a.tokenCost) || 0);
+        },
+        0
+      );
+      suggestions.push({
+        filePath,
+        schemaType,
+        type: "field-removal",
+        message: `${lowValueFields.length} field(s) have low semantic value but high token cost.`,
+        impact: {
+          tokensBefore: totalTokens,
+          tokensAfter: totalTokens - tokenSavings,
+          reduction: Math.round(tokenSavings / totalTokens * 100)
+        },
+        fields: lowValueFields
+      });
+    }
+    const missingHighValueFields = detectMissingHighValueFields(schemaType, schemaData);
+    if (missingHighValueFields.length > 0) {
+      suggestions.push({
+        filePath,
+        schemaType,
+        type: "field-addition",
+        message: `Consider adding high-value fields: ${missingHighValueFields.join(", ")}`,
+        impact: {
+          tokensBefore: totalTokens,
+          tokensAfter: totalTokens + 50
+          // Estimación
+        },
+        fields: missingHighValueFields
+      });
+    }
+    const redundancySuggestions = detectRedundancies(schemaData, filePath, schemaType);
+    suggestions.push(...redundancySuggestions);
+  } catch (error) {
+    console.warn(`Failed to analyze schema in ${filePath}:`, error);
+  }
+  return suggestions;
+}
+function detectMissingHighValueFields(schemaType, data) {
+  const missing = [];
+  const highValueFields = {
+    Article: ["image", "dateModified", "publisher", "description", "wordCount"],
+    Product: ["image", "brand", "aggregateRating", "review"],
+    Organization: ["url", "logo", "sameAs", "description"],
+    Person: ["image", "url", "sameAs", "description"],
+    LocalBusiness: ["telephone", "address", "geo", "openingHours"],
+    Event: ["image", "organizer", "eventStatus", "eventAttendanceMode"]
+  };
+  const recommendedFields = highValueFields[schemaType] || [];
+  for (const field of recommendedFields) {
+    if (!hasField2(data, field)) {
+      missing.push(field);
+    }
+  }
+  return missing;
+}
+function detectRedundancies(data, filePath, schemaType) {
+  const suggestions = [];
+  if (data.publisher) {
+    if (data.publisher["@id"] && data.publisher.url) {
+      if (data.publisher["@id"] === data.publisher.url) {
+        suggestions.push({
+          filePath,
+          schemaType,
+          type: "field-removal",
+          message: "Redundant @id and url in publisher (same value)",
+          impact: {
+            reduction: 5
+          },
+          fields: ["publisher.@id"]
+        });
+      }
+    }
+  }
+  const maxDepth = getMaxDepth(data);
+  if (maxDepth > 4) {
+    suggestions.push({
+      filePath,
+      schemaType,
+      type: "field-update",
+      message: `Schema has deep nesting (${maxDepth} levels). Consider flattening.`,
+      impact: {
+        reduction: 10
+      }
+    });
+  }
+  const largeArrays = findLargeArrays(data);
+  if (largeArrays.length > 0) {
+    suggestions.push({
+      filePath,
+      schemaType,
+      type: "field-update",
+      message: `Large arrays found: ${largeArrays.join(", ")}. Consider limiting.`,
+      impact: {
+        reduction: 15
+      },
+      fields: largeArrays
+    });
+  }
+  return suggestions;
+}
+function hasField2(obj, fieldPath) {
+  const parts = fieldPath.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (!current || typeof current !== "object" || !(part in current)) {
+      return false;
+    }
+    current = current[part];
+  }
+  return current !== void 0 && current !== null;
+}
+function getMaxDepth(obj, currentDepth = 0) {
+  if (typeof obj !== "object" || obj === null) {
+    return currentDepth;
+  }
+  let maxDepth = currentDepth;
+  for (const value of Object.values(obj)) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      const depth = getMaxDepth(value, currentDepth + 1);
+      maxDepth = Math.max(maxDepth, depth);
+    }
+  }
+  return maxDepth;
+}
+function findLargeArrays(obj, path2 = "") {
+  const largeArrays = [];
+  if (Array.isArray(obj) && obj.length > 10) {
+    largeArrays.push(path2 || "root");
+  }
+  if (typeof obj === "object" && obj !== null) {
+    for (const [key, value] of Object.entries(obj)) {
+      const newPath = path2 ? `${path2}.${key}` : key;
+      largeArrays.push(...findLargeArrays(value, newPath));
+    }
+  }
+  return largeArrays;
+}
+function getOptimizationSummary(suggestions) {
+  const totalReduction = suggestions.reduce(
+    (sum, s) => sum + (s.impact.reduction || 0),
+    0
+  );
+  const byType = {};
+  for (const suggestion of suggestions) {
+    byType[suggestion.type] = (byType[suggestion.type] || 0) + 1;
+  }
+  const topOpportunities = suggestions.slice(0, 5).sort((a, b) => (b.impact.reduction || 0) - (a.impact.reduction || 0));
+  return {
+    totalReduction: Math.round(totalReduction / Math.max(1, suggestions.length)),
+    byType,
+    topOpportunities
+  };
+}
+
+// src/auditor/index.ts
+async function auditProject(options = {}) {
+  console.log("\u{1F50D} Scanning project...");
+  const scanResult = await scanProject({
+    ...options.rootDir && { rootDir: options.rootDir },
+    ...options.include && { include: options.include },
+    ...options.exclude && { exclude: options.exclude },
+    ...options.maxDepth && { maxDepth: options.maxDepth },
+    ...options.deepAnalysis !== void 0 && { deepAnalysis: options.deepAnalysis }
+  });
+  console.log(
+    `\u2705 Found ${scanResult.filesWithSchemas.length} files with schemas`
+  );
+  console.log("\u{1F52C} Validating schemas...");
+  const validationResult = await validateSchemas(scanResult, {
+    ...options.strict !== void 0 && { strict: options.strict },
+    ...options.schemaTypes && { schemaTypes: options.schemaTypes },
+    ...options.ignore && { ignore: options.ignore }
+  });
+  if (validationResult.errors > 0) {
+    console.log(`\u274C Found ${validationResult.errors} errors`);
+  }
+  if (validationResult.warnings > 0) {
+    console.log(`\u26A0\uFE0F  Found ${validationResult.warnings} warnings`);
+  }
+  let optimizations = [];
+  if (options.includeOptimizations !== false) {
+    console.log("\u{1F4A1} Analyzing optimizations...");
+    optimizations = await generateOptimizationSuggestions(
+      scanResult,
+      options.targetModel || "gpt-4"
+    );
+    if (optimizations.length > 0) {
+      console.log(`\u{1F4A1} Found ${optimizations.length} optimization opportunities`);
+    }
+  }
+  console.log("\u{1F4CA} Generating report...");
+  const report = generateCoverageReport(
+    scanResult,
+    validationResult,
+    optimizations
+  );
+  if (options.output) {
+    await saveReport(report, {
+      ...options.format && { format: options.format },
+      output: options.output
+    });
+    console.log(`\u2705 Report saved to: ${options.output}`);
+  }
+  return report;
+}
+async function quickValidate(options = {}) {
+  const scanResult = await scanProject({
+    ...options.rootDir && { rootDir: options.rootDir },
+    ...options.include && { include: options.include },
+    ...options.exclude && { exclude: options.exclude }
+  });
+  const validationResult = await validateSchemas(scanResult, {
+    ...options.strict !== void 0 && { strict: options.strict },
+    ...options.schemaTypes && { schemaTypes: options.schemaTypes },
+    ...options.ignore && { ignore: options.ignore }
+  });
+  return validationResult.valid;
+}
+async function generateReportOnly(scanResult, validationResult, options = {}) {
+  const report = generateCoverageReport(scanResult, validationResult);
+  await saveReport(report, options);
+}
+
+export { auditProject, generateCoverageReport, generateOptimizationSuggestions, generateReportOnly, getOptimizationSummary, getProjectStats, quickValidate, saveReport, scanProject, validateSchemas, validateSingleSchema };
+//# sourceMappingURL=auditor.js.map
+//# sourceMappingURL=auditor.js.map