@aravindc26/velu 0.11.0 → 0.11.3

package/src/engine/app/robots.txt/route.ts

@@ -0,0 +1,63 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getSeoConfig, getSiteOrigin } from '@/lib/velu';
+
+export const dynamic = 'force-static';
+
+async function readCustomRobotsFile(): Promise<string | null> {
+  const docsDir = process.env.VELU_DOCS_DIR?.trim();
+  if (docsDir) {
+    const docsPath = join(docsDir, 'robots.txt');
+    if (!existsSync(docsPath)) return null;
+    try {
+      return await readFile(docsPath, 'utf-8');
+    } catch {
+      return null;
+    }
+  }
+
+  const candidates = [
+    join(process.cwd(), 'robots.txt'),
+    join(process.cwd(), 'public', 'robots.txt'),
+  ];
+
+  for (const candidate of candidates) {
+    if (!existsSync(candidate)) continue;
+    try {
+      return await readFile(candidate, 'utf-8');
+    } catch {
+      // ignore and continue
+    }
+  }
+
+  return null;
+}
+
+export async function GET(): Promise<Response> {
+  const custom = await readCustomRobotsFile();
+  if (custom !== null) {
+    return new Response(custom, {
+      headers: {
+        'content-type': 'text/plain; charset=utf-8',
+      },
+    });
+  }
+
+  const seo = getSeoConfig();
+  const origin = getSiteOrigin();
+  const robotsTag = (seo.metatags.robots ?? '').toLowerCase();
+  const blockAll = robotsTag.includes('noindex') || robotsTag.includes('none');
+  const lines = [
+    'User-agent: *',
+    blockAll ? 'Disallow: /' : 'Allow: /',
+    `Sitemap: ${origin}/sitemap.xml`,
+    '',
+  ];
+
+  return new Response(lines.join('\n'), {
+    headers: {
+      'content-type': 'text/plain; charset=utf-8',
+    },
+  });
+}

package/src/engine/app/rss-file/[...slug]/route.ts

@@ -0,0 +1,169 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { source } from '@/lib/source';
+import {
+  getUpdateRssEntries,
+  parseChangelogFromMarkdown,
+  parseFrontmatterValue,
+} from '@/lib/changelog';
+import { getLanguages, getSiteOrigin } from '@/lib/velu';
+
+interface RouteParams {
+  slug?: string[];
+}
+
+export const dynamic = 'force-static';
+
+function normalizePath(value: string): string {
+  if (!value) return '/';
+  const withLeadingSlash = value.startsWith('/') ? value : `/${value}`;
+  const collapsed = withLeadingSlash.replace(/\/{2,}/g, '/');
+  if (collapsed !== '/' && collapsed.endsWith('/')) return collapsed.slice(0, -1);
+  return collapsed;
+}
+
+function cdata(value: string): string {
+  return `<![CDATA[${value.replace(/]]>/g, ']]]]><![CDATA[>')}]]>`;
+}
+
+function toUtcDate(value: string | undefined): string {
+  if (!value) return new Date().toUTCString();
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) return new Date().toUTCString();
+  return parsed.toUTCString();
+}
+
+function resolveLocaleSlug(slugInput: string[] | undefined) {
+  const languages = getLanguages();
+  const defaultLanguage = languages[0] ?? 'en';
+  const slug = slugInput ?? [];
+  const firstSeg = slug[0];
+  const hasLocalePrefix = languages.includes(firstSeg ?? '');
+
+  return {
+    locale: hasLocalePrefix ? firstSeg! : defaultLanguage,
+    pageSlug: hasLocalePrefix ? slug.slice(1) : slug,
+  };
+}
+
+async function loadMarkdownForSlug(slug: string[], locale: string, hasI18n: boolean): Promise<string | undefined> {
+  const rel = slug.join('/');
+  const docsRoots = [
+    join(process.cwd(), 'content', 'docs'),
+    join(process.cwd(), '.velu-out', 'content', 'docs'),
+  ];
+  const roots = hasI18n
+    ? docsRoots.flatMap((root) => [join(root, locale), root])
+    : docsRoots;
+  const paths = roots.flatMap((root) => [join(root, `${rel}.md`), join(root, `${rel}.mdx`)]);
+
+  for (const filePath of paths) {
+    try {
+      return await readFile(filePath, 'utf-8');
+    } catch {
+      // ignore and continue
+    }
+  }
+
+  return undefined;
+}
+
+export async function generateStaticParams() {
+  const generated = source.generateParams('slug') as Array<{ slug?: string[] }>;
+  const seen = new Set<string>();
+  const out: Array<{ slug: string[] }> = [];
+
+  for (const entry of generated) {
+    const slug = entry.slug ?? [];
+    if (slug.length === 0) continue;
+    const key = slug.join('/');
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ slug });
+  }
+
+  return out;
+}
+
+export async function GET(_request: Request, { params }: { params: Promise<RouteParams> }) {
+  const resolvedParams = await params;
+  const fullSlug = resolvedParams.slug ?? [];
+
+  if (fullSlug.length === 0) {
+    return new Response('Not Found', {
+      status: 404,
+      headers: { 'content-type': 'text/plain; charset=utf-8' },
+    });
+  }
+
+  const { locale, pageSlug } = resolveLocaleSlug(fullSlug);
+  const hasI18n = getLanguages().length > 1;
+  const page = hasI18n ? source.getPage(pageSlug, locale) : source.getPage(pageSlug);
+
+  if (!page) {
+    return new Response('Not Found', {
+      status: 404,
+      headers: { 'content-type': 'text/plain; charset=utf-8' },
+    });
+  }
+
+  const fromFile = await loadMarkdownForSlug(pageSlug, locale, hasI18n);
+  const fromData = ((page.data as unknown) as Record<string, unknown>).processedMarkdown;
+  const markdown = typeof fromFile === 'string' && fromFile.trim().length > 0
+    ? fromFile
+    : (typeof fromData === 'string' ? fromData : undefined);
+  const parsed = parseChangelogFromMarkdown(markdown);
+  if (parsed.updates.length === 0) {
+    return new Response('Not Found', {
+      status: 404,
+      headers: { 'content-type': 'text/plain; charset=utf-8' },
+    });
+  }
+
+  const origin = getSiteOrigin();
+  const pagePath = normalizePath(fullSlug.join('/'));
+  const pageUrl = `${origin}${pagePath}`;
+  const rssUrl = `${pageUrl.replace(/\/$/, '')}/rss.xml`;
+
+  const channelTitle = parseFrontmatterValue(markdown, 'title') ?? page.data.title ?? 'Changelog';
+  const channelDescription = parseFrontmatterValue(markdown, 'description')
+    ?? page.data.description
+    ?? 'Product updates and announcements';
+
+  const items = parsed.updates.flatMap((update) => {
+    const entries = getUpdateRssEntries(update);
+    const pubDate = toUtcDate(update.date ?? update.label);
+    return entries.map((entry) => {
+      const link = `${pageUrl.replace(/\/$/, '')}#${entry.anchor || update.anchor}`;
+      return `<item>
+      <title>${cdata(entry.title)}</title>
+      <description>${cdata(entry.description)}</description>
+      <link>${link}</link>
+      <guid isPermaLink="true">${link}</guid>
+      <pubDate>${pubDate}</pubDate>
+    </item>`;
+    });
+  });
+
+  const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<rss xmlns:atom="http://www.w3.org/2005/Atom" version="2.0">
+  <channel>
+    <title>${cdata(channelTitle)}</title>
+    <description>${cdata(channelDescription)}</description>
+    <link>${pageUrl}</link>
+    <generator>Velu</generator>
+    <lastBuildDate>${new Date().toUTCString()}</lastBuildDate>
+    <atom:link href="${rssUrl}" rel="self" type="application/rss+xml"/>
+    ${items.join('\n    ')}
+  </channel>
+</rss>
+`;
+
+  return new Response(xml, {
+    status: 200,
+    headers: {
+      'content-type': 'application/rss+xml; charset=utf-8',
+      'cache-control': 'public, max-age=300',
+    },
+  });
+}

package/src/engine/app/sitemap.xml/route.ts

@@ -0,0 +1,82 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { collectLlmsPages, normalizePath } from '@/lib/llms';
+import { getSeoConfig, getSiteOrigin } from '@/lib/velu';
+
+export const dynamic = 'force-static';
+
+function escapeXml(value: string): string {
+  return value
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+async function readCustomSitemapFile(): Promise<string | null> {
+  const docsDir = process.env.VELU_DOCS_DIR?.trim();
+  if (docsDir) {
+    const docsPath = join(docsDir, 'sitemap.xml');
+    if (!existsSync(docsPath)) return null;
+    try {
+      return await readFile(docsPath, 'utf-8');
+    } catch {
+      return null;
+    }
+  }
+
+  const candidates = [
+    join(process.cwd(), 'sitemap.xml'),
+    join(process.cwd(), 'public', 'sitemap.xml'),
+  ];
+
+  for (const candidate of candidates) {
+    if (!existsSync(candidate)) continue;
+    try {
+      return await readFile(candidate, 'utf-8');
+    } catch {
+      // ignore and continue
+    }
+  }
+
+  return null;
+}
+
+export async function GET(): Promise<Response> {
+  const custom = await readCustomSitemapFile();
+  if (custom !== null) {
+    return new Response(custom, {
+      headers: {
+        'content-type': 'application/xml; charset=utf-8',
+      },
+    });
+  }
+
+  const seo = getSeoConfig();
+  const origin = getSiteOrigin();
+  const pages = await collectLlmsPages({ indexing: seo.indexing });
+  const now = new Date().toISOString();
+
+  const urls = pages
+    .filter((page) => !page.noindex)
+    .map((page) => {
+      const loc = escapeXml(`${origin}${normalizePath(page.path)}`);
+      return `  <url><loc>${loc}</loc><lastmod>${now}</lastmod></url>`;
+    });
+
+  const xml = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+    ...urls,
+    '</urlset>',
+    '',
+  ].join('\n');
+
+  return new Response(xml, {
+    headers: {
+      'content-type': 'application/xml; charset=utf-8',
+    },
+  });
+}

package/src/engine/components/assistant.tsx

@@ -305,19 +305,30 @@ function initAssistant() {
     else if (action === 'reset') resetChat();
   });
 
-  // Scroll: hide ask bar at bottom of page
-  window.addEventListener('scroll', () => {
+  // Hide ask bar only when truly near the page bottom.
+  function syncAskBarVisibility() {
     if (isPanelOpen()) return;
     const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
     const docHeight = document.documentElement.scrollHeight;
     const winHeight = window.innerHeight;
-    if (docHeight <= winHeight + 10) return;
-    if (docHeight - scrollTop - winHeight < 60) {
+    const bottomGap = docHeight - scrollTop - winHeight;
+    const nearBottomThreshold = 8;
+
+    if (docHeight <= winHeight + 2) {
+      askBar.classList.remove('velu-ask-bar-hidden');
+      return;
+    }
+
+    if (bottomGap <= nearBottomThreshold) {
       askBar.classList.add('velu-ask-bar-hidden');
     } else {
       askBar.classList.remove('velu-ask-bar-hidden');
     }
-  }, { passive: true });
+  }
+
+  window.addEventListener('scroll', syncAskBarVisibility, { passive: true });
+  window.addEventListener('resize', syncAskBarVisibility, { passive: true });
+  syncAskBarVisibility();
 
   document.addEventListener('keydown', (e) => {
     if (e.key === 'Escape' && isPanelOpen()) closePanel();

package/src/engine/components/changelog-filters.tsx

@@ -0,0 +1,114 @@
+'use client';
+
+import { createPortal } from 'react-dom';
+import { useEffect, useMemo, useState } from 'react';
+
+interface ChangelogFiltersProps {
+  tags: string[];
+}
+
+function normalize(value: string): string {
+  return value.trim().toLowerCase();
+}
+
+function parseNodeTags(value: string | undefined): string[] {
+  if (!value) return [];
+  return value
+    .split('|')
+    .map((tag) => normalize(tag))
+    .filter(Boolean);
+}
+
+const VELU_CHANGELOG_FILTER_HOST_ID = 'velu-changelog-filter-host';
+
+function ensureTocHost(): HTMLDivElement | null {
+  if (typeof document === 'undefined') return null;
+  const toc = document.getElementById('nd-toc');
+  if (!toc) return null;
+  toc.classList.add('velu-changelog-filters-only');
+
+  let host = document.getElementById(VELU_CHANGELOG_FILTER_HOST_ID) as HTMLDivElement | null;
+  if (!host) {
+    host = document.createElement('div');
+    host.id = VELU_CHANGELOG_FILTER_HOST_ID;
+    host.className = 'velu-changelog-filter-host';
+    toc.prepend(host);
+  }
+
+  return host;
+}
+
+export function ChangelogFilters({ tags }: ChangelogFiltersProps) {
+  const [selected, setSelected] = useState<string[]>([]);
+  const [tocHost, setTocHost] = useState<HTMLDivElement | null>(null);
+  const uniqueTags = useMemo(
+    () => Array.from(new Set(tags.map((tag) => tag.trim()).filter(Boolean))),
+    [tags],
+  );
+
+  useEffect(() => {
+    let frame = 0;
+    const attach = () => {
+      const host = ensureTocHost();
+      if (host) {
+        setTocHost(host);
+        return;
+      }
+      frame = window.requestAnimationFrame(attach);
+    };
+    attach();
+
+    return () => {
+      if (frame) window.cancelAnimationFrame(frame);
+      const toc = document.getElementById('nd-toc');
+      toc?.classList.remove('velu-changelog-filters-only');
+      const host = document.getElementById(VELU_CHANGELOG_FILTER_HOST_ID);
+      host?.remove();
+    };
+  }, []);
+
+  useEffect(() => {
+    const updates = Array.from(document.querySelectorAll<HTMLElement>('.velu-update'));
+    const normalizedSelected = selected.map((tag) => normalize(tag));
+
+    for (const update of updates) {
+      const updateTags = parseNodeTags(update.dataset.updateTags);
+      const visible = normalizedSelected.length === 0
+        || normalizedSelected.some((tag) => updateTags.includes(tag));
+      update.hidden = !visible;
+    }
+  }, [selected]);
+
+  if (uniqueTags.length === 0) return null;
+
+  const content = (
+    <div className="velu-changelog-filter-block">
+      <div className="velu-changelog-filter-heading">Filters</div>
+      <div className="velu-changelog-filters" role="group" aria-label="Filter updates by tag">
+        {uniqueTags.map((tag) => {
+          const active = selected.some((entry) => normalize(entry) === normalize(tag));
+          return (
+            <button
+              key={tag}
+              type="button"
+              className={['velu-changelog-filter', active ? 'active' : ''].filter(Boolean).join(' ')}
+              onClick={() => {
+                setSelected((prev) => {
+                  const hasTag = prev.some((entry) => normalize(entry) === normalize(tag));
+                  return hasTag
+                    ? prev.filter((entry) => normalize(entry) !== normalize(tag))
+                    : [...prev, tag];
+                });
+              }}
+            >
+              {tag}
+            </button>
+          );
+        })}
+      </div>
+    </div>
+  );
+
+  if (!tocHost) return null;
+  return createPortal(content, tocHost);
+}