bertui 1.2.9 → 2.0.0

package/src/build/compiler/index.js

@@ -1,31 +0,0 @@
-// bertui/src/build/compiler/index.js
-import { join } from 'path';
-import { existsSync } from 'fs';
-import logger from '../../logger/logger.js';
-import { discoverRoutes } from './route-discoverer.js';
-import { compileBuildDirectory } from './file-transpiler.js';
-import { generateBuildRouter } from './router-generator.js';
-
-export async function compileForBuild(root, buildDir, envVars, config = {}) {
-  const srcDir   = join(root, 'src');
-  const pagesDir = join(srcDir, 'pages');
-
-  if (!existsSync(srcDir)) {
-    throw new Error('src/ directory not found!');
-  }
-
-  const importhow = config.importhow || {};
-  let routes = [];
-
-  if (existsSync(pagesDir)) {
-    routes = await discoverRoutes(pagesDir);
-  }
-
-  await compileBuildDirectory(srcDir, buildDir, root, envVars, importhow);
-
-  if (routes.length > 0) {
-    await generateBuildRouter(routes, buildDir);
-  }
-
-  return { routes };
-}

package/src/build/compiler/route-discoverer.js

@@ -1,49 +0,0 @@
-// bertui/src/build/compiler/route-discoverer.js
-import { join, extname } from 'path';
-import { readdirSync, statSync } from 'fs';
-
-export async function discoverRoutes(pagesDir) {
-  const routes = [];
-  
-  async function scanDirectory(dir, basePath = '') {
-    const entries = readdirSync(dir, { withFileTypes: true });
-    
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
-      const relativePath = join(basePath, entry.name);
-      
-      if (entry.isDirectory()) {
-        await scanDirectory(fullPath, relativePath);
-      } else if (entry.isFile()) {
-        const ext = extname(entry.name);
-        if (ext === '.css') continue;
-        
-        if (['.jsx', '.tsx', '.js', '.ts'].includes(ext)) {
-          const fileName = entry.name.replace(ext, '');
-
-          // Only loading is reserved - index is a valid route (becomes /)
-          if (fileName === 'loading') continue;
-
-          let route = '/' + relativePath.replace(/\\/g, '/').replace(ext, '');
-          if (fileName === 'index') {
-            route = route.replace('/index', '') || '/';
-          }
-          
-          const isDynamic = fileName.includes('[') && fileName.includes(']');
-          
-          routes.push({
-            route: route === '' ? '/' : route,
-            file: relativePath.replace(/\\/g, '/'),
-            path: fullPath,
-            type: isDynamic ? 'dynamic' : 'static'
-          });
-        }
-      }
-    }
-  }
-  
-  await scanDirectory(pagesDir);
-  routes.sort((a, b) => a.type === b.type ? a.route.localeCompare(b.route) : a.type === 'static' ? -1 : 1);
-  
-  return routes;
-}

package/src/build/compiler/router-generator.js

@@ -1,105 +0,0 @@
-// bertui/src/build/compiler/router-generator.js
-import { join } from 'path';
-
-export async function generateBuildRouter(routes, buildDir) {
-  const imports = routes.map((route, i) => {
-    const componentName = `Page${i}`;
-    const importPath = `./pages/${route.file.replace(/\.(jsx|tsx|ts)$/, '.js')}`;
-    return `import ${componentName} from '${importPath}';`;
-  }).join('\n');
-
-  const routeConfigs = routes.map((route, i) => {
-    const componentName = `Page${i}`;
-    return `  { path: '${route.route}', component: ${componentName}, type: '${route.type}' }`;
-  }).join(',\n');
-
-  const routerCode = `import React, { useState, useEffect, createContext, useContext } from 'react';
-
-const RouterContext = createContext(null);
-
-export function useRouter() {
-  const context = useContext(RouterContext);
-  if (!context) throw new Error('useRouter must be used within a Router');
-  return context;
-}
-
-export function Router({ routes }) {
-  const [currentRoute, setCurrentRoute] = useState(null);
-  const [params, setParams] = useState({});
-
-  useEffect(() => {
-    matchAndSetRoute(window.location.pathname);
-    const handlePopState = () => matchAndSetRoute(window.location.pathname);
-    window.addEventListener('popstate', handlePopState);
-    return () => window.removeEventListener('popstate', handlePopState);
-  }, [routes]);
-
-  function matchAndSetRoute(pathname) {
-    for (const route of routes) {
-      if (route.type === 'static' && route.path === pathname) {
-        setCurrentRoute(route);
-        setParams({});
-        return;
-      }
-    }
-    for (const route of routes) {
-      if (route.type === 'dynamic') {
-        const pattern = route.path.replace(/\\[([^\\]]+)\\]/g, '([^/]+)');
-        const regex = new RegExp('^' + pattern + '$');
-        const match = pathname.match(regex);
-        if (match) {
-          const paramNames = [...route.path.matchAll(/\\[([^\\]]+)\\]/g)].map(m => m[1]);
-          const extractedParams = {};
-          paramNames.forEach((name, i) => { extractedParams[name] = match[i + 1]; });
-          setCurrentRoute(route);
-          setParams(extractedParams);
-          return;
-        }
-      }
-    }
-    setCurrentRoute(null);
-    setParams({});
-  }
-
-  function navigate(path) {
-    window.history.pushState({}, '', path);
-    matchAndSetRoute(path);
-  }
-
-  const Component = currentRoute?.component;
-  return React.createElement(
-    RouterContext.Provider,
-    { value: { currentRoute, params, navigate, pathname: window.location.pathname } },
-    Component ? React.createElement(Component, { params }) : React.createElement(NotFound)
-  );
-}
-
-export function Link({ to, children, ...props }) {
-  const { navigate } = useRouter();
-  return React.createElement('a', {
-    href: to,
-    onClick: (e) => { e.preventDefault(); navigate(to); },
-    ...props
-  }, children);
-}
-
-function NotFound() {
-  return React.createElement('div', {
-    style: { display: 'flex', flexDirection: 'column', alignItems: 'center',
-             justifyContent: 'center', minHeight: '100vh', fontFamily: 'system-ui' }
-  },
-    React.createElement('h1', { style: { fontSize: '6rem', margin: 0 } }, '404'),
-    React.createElement('p', { style: { fontSize: '1.5rem', color: '#666' } }, 'Page not found'),
-    React.createElement('a', { href: '/', style: { color: '#10b981', textDecoration: 'none' } }, 'Go home')
-  );
-}
-
-${imports}
-
-export const routes = [
-${routeConfigs}
-];
-`;
-
-  await Bun.write(join(buildDir, 'router.js'), routerCode);
-}

package/src/build/css-builder.js

@@ -1,81 +0,0 @@
-import { join } from 'path';
-import { existsSync, mkdirSync } from 'fs';
-import { transform } from 'lightningcss';
-import logger from '../logger/logger.js';
-
-/**
- * Build and minify CSS for production using Lightning CSS
- * @param {string} srcPath - Source CSS file path
- * @param {string} destPath - Destination CSS file path
- */
-export async function buildCSS(srcPath, destPath) {
-  try {
-    logger.info(`Processing CSS: ${srcPath.split('/').pop()}`);
-    
-    // Ensure destination directory exists
-    const destDir = join(destPath, '..');
-    if (!existsSync(destDir)) {
-      mkdirSync(destDir, { recursive: true });
-    }
-    
-    // Read source CSS
-    const css = await Bun.file(srcPath).text();
-    const originalSize = Buffer.byteLength(css);
-    
-    // Transform with Lightning CSS (blazing fast)
-    const { code } = transform({
-      filename: srcPath,
-      code: Buffer.from(css),
-      minify: true,
-      sourceMap: false,
-      targets: {
-        // Support last 2 versions of major browsers
-        chrome: 90 << 16,
-        firefox: 88 << 16,
-        safari: 14 << 16,
-        edge: 90 << 16
-      },
-      drafts: {
-        nesting: true // Enable CSS nesting
-      }
-    });
-    
-    // Write minified CSS
-    await Bun.write(destPath, code);
-    
-    // Calculate size reduction
-    const minifiedSize = code.length;
-    const originalKB = (originalSize / 1024).toFixed(2);
-    const minifiedKB = (minifiedSize / 1024).toFixed(2);
-    const reduction = ((1 - minifiedSize / originalSize) * 100).toFixed(1);
-    
-    logger.success(`CSS minified: ${originalKB}KB → ${minifiedKB}KB (-${reduction}%)`);
-    
-    return { success: true, size: minifiedKB };
-  } catch (error) {
-    logger.error(`CSS build failed: ${error.message}`);
-    throw error;
-  }
-}
-
-/**
- * Copy CSS without minification (for dev)
- * @param {string} srcPath - Source CSS file path
- * @param {string} destPath - Destination CSS file path
- */
-export async function copyCSS(srcPath, destPath) {
-  try {
-    const destDir = join(destPath, '..');
-    if (!existsSync(destDir)) {
-      mkdirSync(destDir, { recursive: true });
-    }
-    
-    await Bun.write(destPath, Bun.file(srcPath));
-    logger.info('CSS copied for development');
-    
-    return { success: true };
-  } catch (error) {
-    logger.error(`CSS copy failed: ${error.message}`);
-    throw error;
-  }
-}

package/src/build/generators/html-generator.js

@@ -1,263 +0,0 @@
-// bertui/src/build/generators/html-generator.js
-import { join, relative } from 'path'
-import { mkdirSync, existsSync, cpSync } from 'fs'
-import logger from '../../logger/logger.js'
-import { extractMetaFromSource } from '../../utils/meta-extractor.js'
-import { renderPageToHTML, getPageRenderMode } from '../ssr-renderer.js'
-
-export async function generateProductionHTML(root, outDir, buildResult, routes, config, buildDir) {
-  const mainBundle = buildResult.outputs.find(o =>
-    o.path.includes('main') && o.kind === 'entry-point'
-  )
-
-  if (!mainBundle) {
-    logger.error('Could not find main bundle')
-    return
-  }
-
-  const bundlePath = relative(outDir, mainBundle.path).replace(/\\/g, '/')
-  const defaultMeta = config.meta || {}
-  const bertuiPackages = await copyBertuiPackagesToProduction(root, outDir)
-
-
-  logger.info(`Generating HTML for ${routes.length} routes...`)
-
-  for (const route of routes) {
-    await processSingleRoute(route, config, defaultMeta, bundlePath, outDir, bertuiPackages, buildDir)
-  }
-
-  logger.success(`HTML generation complete for ${routes.length} routes`)
-}
-
-async function processSingleRoute(route, config, defaultMeta, bundlePath, outDir, bertuiPackages, buildDir) {
-  try {
-    const sourceCode = await Bun.file(route.path).text()
-    const pageMeta = extractMetaFromSource(sourceCode)
-    const meta = { ...defaultMeta, ...pageMeta }
-
-    // Determine render mode from source
-    const renderMode = await getPageRenderMode(route.path)
-
-    let html
-
-    if (renderMode === 'server' || renderMode === 'static') {
-      // Find the compiled version of this page in buildDir
-      const compiledPath = findCompiledPath(route, buildDir)
-
-      if (compiledPath && existsSync(compiledPath)) {
-        logger.info(`  SSR rendering: ${route.route}`)
-        const ssrHTML = await renderPageToHTML(compiledPath, buildDir)
-
-        if (ssrHTML) {
-          if (renderMode === 'static') {
-            // Pure static — no JS at all
-            html = generateStaticHTML({ ssrHTML, meta, bertuiPackages })
-          } else {
-            // Server island — SSR HTML + JS bundle for hydration
-            html = generateServerIslandHTML({ ssrHTML, meta, bundlePath, bertuiPackages })
-          }
-          logger.success(`  ✓ SSR: ${route.route} (${renderMode})`)
-        } else {
-          // SSR failed — fall back to client render with a warning
-          logger.warn(`  SSR failed for ${route.route}, falling back to client render`)
-          html = generateClientHTML({ meta, bundlePath, bertuiPackages })
-        }
-      } else {
-        logger.warn(`  Compiled path not found for ${route.route}, using client render`)
-        html = generateClientHTML({ meta, bundlePath, bertuiPackages })
-      }
-    } else {
-      // Default: client-only SPA
-      html = generateClientHTML({ meta, bundlePath, bertuiPackages })
-    }
-
-    // Write to dist/
-    let htmlPath
-    if (route.route === '/') {
-      htmlPath = join(outDir, 'index.html')
-    } else {
-      const routeDir = join(outDir, route.route.replace(/^\//, ''))
-      mkdirSync(routeDir, { recursive: true })
-      htmlPath = join(routeDir, 'index.html')
-    }
-
-    await Bun.write(htmlPath, html)
-    logger.success(`  ${route.route}`)
-
-  } catch (error) {
-    logger.error(`Failed HTML for ${route.route}: ${error.message}`)
-  }
-}
-
-/**
- * Find the compiled .js path for a route's source file
- */
-function findCompiledPath(route, buildDir) {
-  const compiledFile = route.file.replace(/\.(jsx|tsx|ts)$/, '.js')
-  return join(buildDir, 'pages', compiledFile)
-}
-// ─── HTML generators ──────────────────────────────────────────────────────────
-
-/**
- * render = "static" → pure HTML, zero JS
- */
-function generateStaticHTML({ ssrHTML, meta, bertuiPackages }) {
-  const bertuiAnimateCSS = bertuiPackages.bertuiAnimate
-    ? '<link rel="stylesheet" href="/css/bertui-animate.min.css">'
-    : ''
-
-  return `<!DOCTYPE html>
-<html lang="${meta.lang || 'en'}">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>${meta.title || 'BertUI App'}</title>
-  <meta name="description" content="${meta.description || ''}">
-  ${meta.keywords     ? `<meta name="keywords" content="${meta.keywords}">` : ''}
-  ${meta.author       ? `<meta name="author" content="${meta.author}">` : ''}
-  ${meta.themeColor   ? `<meta name="theme-color" content="${meta.themeColor}">` : ''}
-  <meta property="og:title" content="${meta.ogTitle || meta.title || 'BertUI App'}">
-  <meta property="og:description" content="${meta.ogDescription || meta.description || ''}">
-  ${meta.ogImage ? `<meta property="og:image" content="${meta.ogImage}">` : ''}
-  <link rel="stylesheet" href="/styles/bertui.min.css">
-  ${bertuiAnimateCSS}
-  <link rel="icon" type="image/svg+xml" href="/favicon.svg">
-</head>
-<body>
-  ${ssrHTML}
-</body>
-</html>`
-}
-
-/**
- * render = "server" → SSR HTML + JS bundle for hydration
- */
-function generateServerIslandHTML({ ssrHTML, meta, bundlePath, bertuiPackages }) {
-  const { importMapScript, bertuiAnimateCSS } = buildSharedAssets(meta, bertuiPackages)
-
-  return `<!DOCTYPE html>
-<html lang="${meta.lang || 'en'}">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>${meta.title || 'BertUI App'}</title>
-  <meta name="description" content="${meta.description || ''}">
-  ${meta.keywords     ? `<meta name="keywords" content="${meta.keywords}">` : ''}
-  ${meta.author       ? `<meta name="author" content="${meta.author}">` : ''}
-  ${meta.themeColor   ? `<meta name="theme-color" content="${meta.themeColor}">` : ''}
-  <meta property="og:title" content="${meta.ogTitle || meta.title || 'BertUI App'}">
-  <meta property="og:description" content="${meta.ogDescription || meta.description || ''}">
-  ${meta.ogImage ? `<meta property="og:image" content="${meta.ogImage}">` : ''}
-  <link rel="stylesheet" href="/styles/bertui.min.css">
-  ${bertuiAnimateCSS}
-  <link rel="icon" type="image/svg+xml" href="/favicon.svg">
-  ${importMapScript}
-</head>
-<body>
-  <div id="root">${ssrHTML}</div>
-  <script type="module" src="/${bundlePath}"></script>
-</body>
-</html>`
-}
-
-/**
- * default → client-only SPA (existing behavior)
- */
-function generateClientHTML({ meta, bundlePath, bertuiPackages }) {
-  const { importMapScript, bertuiAnimateCSS } = buildSharedAssets(meta, bertuiPackages)
-
-  return `<!DOCTYPE html>
-<html lang="${meta.lang || 'en'}">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>${meta.title || 'BertUI App'}</title>
-  <meta name="description" content="${meta.description || ''}">
-  ${meta.keywords     ? `<meta name="keywords" content="${meta.keywords}">` : ''}
-  ${meta.author       ? `<meta name="author" content="${meta.author}">` : ''}
-  ${meta.themeColor   ? `<meta name="theme-color" content="${meta.themeColor}">` : ''}
-  <meta property="og:title" content="${meta.ogTitle || meta.title || 'BertUI App'}">
-  <meta property="og:description" content="${meta.ogDescription || meta.description || ''}">
-  ${meta.ogImage ? `<meta property="og:image" content="${meta.ogImage}">` : ''}
-  <link rel="stylesheet" href="/styles/bertui.min.css">
-  ${bertuiAnimateCSS}
-  <link rel="icon" type="image/svg+xml" href="/favicon.svg">
-  ${importMapScript}
-</head>
-<body>
-  <div id="root"></div>
-  <script type="module" src="/${bundlePath}"></script>
-</body>
-</html>`
-}
-
-// ─── Shared helpers ───────────────────────────────────────────────────────────
-
-function buildSharedAssets(meta, bertuiPackages) {
-  const bertuiIconsImport = bertuiPackages.bertuiIcons
-    ? ',\n      "bertui-icons": "/node_modules/bertui-icons/generated/index.js"'
-    : ''
-  const elysiaEdenImport = bertuiPackages.elysiaEden
-    ? ',\n      "@elysiajs/eden": "/node_modules/@elysiajs/eden/dist/index.mjs"'
-    : ''
-  const bertuiAnimateCSS = bertuiPackages.bertuiAnimate
-    ? '<link rel="stylesheet" href="/css/bertui-animate.min.css">'
-    : ''
-
-  const importMapScript = `<script type="importmap">
-  {
-    "imports": {
-      "react": "https://esm.sh/react@18.2.0",
-      "react-dom": "https://esm.sh/react-dom@18.2.0",
-      "react-dom/client": "https://esm.sh/react-dom@18.2.0/client",
-      "react/jsx-runtime": "https://esm.sh/react@18.2.0/jsx-runtime",
-      "react/jsx-dev-runtime": "https://esm.sh/react@18.2.0/jsx-dev-runtime",
-      "@bunnyx/api": "/bunnyx-api/api-client.js"${bertuiIconsImport}${elysiaEdenImport}
-    }
-  }
-  </script>`
-
-  return { importMapScript, bertuiAnimateCSS }
-}
-
-async function copyBertuiPackagesToProduction(root, outDir) {
-  const nodeModulesDir = join(root, 'node_modules')
-  const packages = { bertuiIcons: false, bertuiAnimate: false, elysiaEden: false }
-
-  if (!existsSync(nodeModulesDir)) return packages
-
-  const bertuiIconsSrc = join(nodeModulesDir, 'bertui-icons')
-  if (existsSync(bertuiIconsSrc)) {
-    try {
-      const dest = join(outDir, 'node_modules', 'bertui-icons')
-      mkdirSync(join(outDir, 'node_modules'), { recursive: true })
-      cpSync(bertuiIconsSrc, dest, { recursive: true })
-      packages.bertuiIcons = true
-    } catch {}
-  }
-
-  const bertuiAnimateSrc = join(nodeModulesDir, 'bertui-animate', 'dist')
-  if (existsSync(bertuiAnimateSrc)) {
-    try {
-      const dest = join(outDir, 'css')
-      mkdirSync(dest, { recursive: true })
-      const minCSS = join(bertuiAnimateSrc, 'bertui-animate.min.css')
-      if (existsSync(minCSS)) {
-        cpSync(minCSS, join(dest, 'bertui-animate.min.css'))
-        packages.bertuiAnimate = true
-      }
-    } catch {}
-  }
-
-  const elysiaEdenSrc = join(nodeModulesDir, '@elysiajs', 'eden')
-  if (existsSync(elysiaEdenSrc)) {
-    try {
-      const dest = join(outDir, 'node_modules', '@elysiajs', 'eden')
-      mkdirSync(join(outDir, 'node_modules', '@elysiajs'), { recursive: true })
-      cpSync(elysiaEdenSrc, dest, { recursive: true })
-      packages.elysiaEden = true
-    } catch {}
-  }
-
-  return packages
-}

package/src/build/generators/robots-generator.js

@@ -1,58 +0,0 @@
-// bertui/src/build/robots-generator.js
-import { join } from 'path';
-import logger from '../../logger/logger.js';
-
-/**
- * Generate robots.txt from sitemap data
- * @param {Object} config - BertUI config with baseUrl
- * @param {string} outDir - Output directory (dist/)
- * @param {Array} routes - Optional: routes to disallow (e.g., admin pages)
- */
-export async function generateRobots(config, outDir, routes = []) {
-  logger.info('🤖 Generating robots.txt...');
-  
-  // ✅ FIX: Check if baseUrl exists, then remove trailing slash
-  if (!config?.baseUrl) {
-    logger.error('❌ baseUrl is required in bertui.config.js for robots.txt generation!');
-    logger.error('   Add: baseUrl: "https://your-domain.com" to your config');
-    throw new Error('Missing baseUrl in config - robots.txt generation failed');
-  }
-  
-  const baseUrl = config.baseUrl.replace(/\/$/, ''); // Remove trailing slash
-  const sitemapUrl = `${baseUrl}/sitemap.xml`;
-  
-  logger.info(`   Sitemap URL: ${sitemapUrl}`);
-  
-  // Default robots.txt - Allow all
-  let robotsTxt = `# BertUI Generated robots.txt
-User-agent: *
-Allow: /
-
-# Sitemap
-Sitemap: ${sitemapUrl}
-`;
-  
-  // Add custom disallow rules if specified in config
-  if (config?.robots?.disallow && Array.isArray(config.robots.disallow) && config.robots.disallow.length > 0) {
-    robotsTxt += '\n# Custom Disallow Rules\n';
-    config.robots.disallow.forEach(path => {
-      robotsTxt += `Disallow: ${path}\n`;
-    });
-    logger.info(`   Blocked ${config.robots.disallow.length} path(s)`);
-  }
-  
-  // Add crawl delay if specified
-  if (config?.robots?.crawlDelay && typeof config.robots.crawlDelay === 'number') {
-    robotsTxt += `\nCrawl-delay: ${config.robots.crawlDelay}\n`;
-    logger.info(`   Crawl delay: ${config.robots.crawlDelay}s`);
-  }
-  
-  // Write to dist/robots.txt
-  const robotsPath = join(outDir, 'robots.txt');
-  await Bun.write(robotsPath, robotsTxt);
-  
-  logger.success('✅ robots.txt generated');
-  logger.info(`   Location: ${robotsPath}`);
-  
-  return { path: robotsPath, content: robotsTxt };
-}

package/src/build/generators/sitemap-generator.js

@@ -1,63 +0,0 @@
-// bertui/src/build/sitemap-generator.js - SIMPLIFIED
-import { join } from 'path';
-import logger from '../../logger/logger.js';
-
-function calculatePriority(route) {
-  if (route === '/') return 1.0;
-  if (route.includes(':')) return 0.6;
-  const depth = route.split('/').filter(Boolean).length;
-  if (depth === 1) return 0.8;
-  if (depth === 2) return 0.7;
-  return 0.6;
-}
-
-function generateSitemapXML(routes, baseUrl) {
-  const urls = routes.map(route => {
-    const url = `${baseUrl}${route.route}`;
-    return `  <url>
-    <loc>${url}</loc>
-    <lastmod>${route.lastmod}</lastmod>
-    <changefreq>weekly</changefreq>
-    <priority>${route.priority}</priority>
-  </url>`;
-  }).join('\n');
-  
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-${urls}
-</urlset>`;
-}
-
-export async function generateSitemap(routes, config, outDir) {
-  logger.info('🗺️  Generating sitemap.xml...');
-  
-  if (!config?.baseUrl) {
-    logger.error('❌ baseUrl is required in bertui.config.js for sitemap generation!');
-    logger.error('   Add: baseUrl: "https://your-domain.com" to your config');
-    throw new Error('Missing baseUrl in config - sitemap generation failed');
-  }
-  
-  const baseUrl = config.baseUrl.replace(/\/$/, '');
-  const currentDate = new Date().toISOString().split('T')[0];
-  
-  logger.info(`   Base URL: ${baseUrl}`);
-  
-  const staticRoutes = routes.filter(r => r.type === 'static');
-  logger.info(`   ${staticRoutes.length} static routes will be included in sitemap`);
-  
-  // SIMPLE: No file reading, just route processing
-  const sitemapRoutes = staticRoutes.map(route => ({
-    route: route.route,
-    lastmod: currentDate,
-    priority: calculatePriority(route.route)
-  }));
-  
-  const xml = generateSitemapXML(sitemapRoutes, baseUrl);
-  const sitemapPath = join(outDir, 'sitemap.xml');
-  await Bun.write(sitemapPath, xml);
-  
-  logger.success(`✅ Sitemap generated: ${sitemapRoutes.length} URLs`);
-  logger.info(`   Location: ${sitemapPath}`);
-  
-  return { routes: sitemapRoutes, path: sitemapPath };
-}