@hutusi/amytis 1.13.0 → 1.14.0

package/src/lib/feed-utils.ts

@@ -7,6 +7,7 @@ import rehypeStringify from 'rehype-stringify';
 import { getAllPosts, getAllFlows } from './markdown';
 import { siteConfig } from '../../site.config';
 import { getPostUrl, getFlowUrl } from './urls';
+import { resolveLocale } from './i18n';
 
 export interface FeedItem {
   title: string;
@@ -30,39 +31,178 @@ function markdownToHtml(markdown: string): string {
   return String(result);
 }
 
+export type FeedType = 'main' | 'posts' | 'flows' | 'all';
+
 /**
  * Returns feed items for RSS/Atom generation.
- * Includes all published posts (converted to HTML) and optionally flow notes
- * when `siteConfig.feed.includeFlows` is enabled. Results are sorted by date
- * descending and capped at `siteConfig.feed.maxItems` (0 = unlimited).
+ * - 'main': Respects `siteConfig.feed.includeFlows`
+ * - 'posts': Only posts
+ * - 'flows': Only flows
+ * - 'all': Both posts and flows, ignoring `includeFlows`
  */
-export function getFeedItems(): FeedItem[] {
+export function getFeedItems(feedType: FeedType = 'main', includeFullContent: boolean = false): FeedItem[] {
   const { maxItems, includeFlows } = siteConfig.feed;
   const baseUrl = siteConfig.baseUrl.replace(/\/+$/, '');
 
-  const postItems: FeedItem[] = getAllPosts().map((post) => ({
+  let items: FeedItem[] = [];
+
+  const getPostItems = () => getAllPosts().map((post) => ({
     title: post.title,
     url: `${baseUrl}${getPostUrl(post)}`,
     date: new Date(post.date),
     excerpt: post.excerpt,
-    content: markdownToHtml(post.content),
+    content: includeFullContent ? markdownToHtml(post.content) : '',
     tags: post.tags || [],
     authors: post.authors,
   }));
 
-  let items: FeedItem[] = postItems;
-
-  if (includeFlows) {
-    const flowItems: FeedItem[] = getAllFlows().map((flow) => ({
-      title: flow.title,
-      url: `${baseUrl}${getFlowUrl(flow.slug)}`,
-      date: new Date(flow.date),
-      excerpt: flow.excerpt,
-      content: markdownToHtml(flow.content),
-      tags: flow.tags || [],
-    }));
-    items = [...postItems, ...flowItems].sort((a, b) => b.date.getTime() - a.date.getTime());
+  const getFlowItems = () => getAllFlows().map((flow) => ({
+    title: flow.title,
+    url: `${baseUrl}${getFlowUrl(flow.slug)}`,
+    date: new Date(flow.date),
+    excerpt: flow.excerpt,
+    content: includeFullContent ? markdownToHtml(flow.content) : '',
+    tags: flow.tags || [],
+  }));
+
+  if (feedType === 'posts') {
+    items = getPostItems();
+  } else if (feedType === 'flows') {
+    items = getFlowItems();
+  } else if (feedType === 'all') {
+    items = [...getPostItems(), ...getFlowItems()];
+  } else {
+    // main
+    items = includeFlows ? [...getPostItems(), ...getFlowItems()] : getPostItems();
   }
 
+  // Sort descending by date
+  items.sort((a, b) => b.date.getTime() - a.date.getTime());
+
   return maxItems > 0 ? items.slice(0, maxItems) : items;
 }
+
+const escapeXml = (v: string) =>
+  v.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+   .replace(/"/g, '&quot;').replace(/'/g, '&apos;');
+
+const escapeCdata = (v: string) => v.replace(/]]>/g, ']]]]><![CDATA[>');
+
+export function generateRssFeed(feedType: FeedType, selfUrlPath: string): Response {
+  const { format, content: contentMode } = siteConfig.feed;
+  if (format === 'atom') {
+    return new Response('Not Found', { status: 404 });
+  }
+
+  const baseUrl = siteConfig.baseUrl.replace(/\/+$/, '');
+  const useFullContent = contentMode === 'full';
+  const items = getFeedItems(feedType, useFullContent);
+  const contentNs = useFullContent ? ' xmlns:content="http://purl.org/rss/modules/content/"' : '';
+  const siteTitle = resolveLocale(siteConfig.title);
+  const lastBuildDate = items[0]?.date.toUTCString() ?? new Date().toUTCString();
+
+  const selfUrl = `${baseUrl}${selfUrlPath}`;
+
+  const imageXml = siteConfig.ogImage
+    ? `\n    <image>\n      <url>${escapeXml(baseUrl + siteConfig.ogImage)}</url>\n      <title>${escapeXml(siteTitle)}</title>\n      <link>${escapeXml(baseUrl)}</link>\n    </image>`
+    : '';
+
+  const rssItemsXml = items
+    .map((item) => {
+      const fullContentXml = useFullContent
+        ? `\n          <content:encoded><![CDATA[${escapeCdata(item.content)}]]></content:encoded>`
+        : '';
+      const authorsXml = item.authors?.length
+        ? item.authors.map((a) => `\n          <dc:creator><![CDATA[${escapeCdata(a)}]]></dc:creator>`).join('')
+        : '';
+      return `
+        <item>
+          <title><![CDATA[${escapeCdata(item.title)}]]></title>
+          <link>${escapeXml(item.url)}</link>
+          <guid isPermaLink="true">${escapeXml(item.url)}</guid>
+          <pubDate>${item.date.toUTCString()}</pubDate>
+          <description><![CDATA[${escapeCdata(item.excerpt)}]]></description>${fullContentXml}${authorsXml}
+          ${item.tags.map((tag) => `<category><![CDATA[${escapeCdata(tag)}]]></category>`).join('')}
+        </item>`;
+    })
+    .join('');
+
+  const rssXml = `<?xml version="1.0" encoding="UTF-8" ?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/"${contentNs}>
+  <channel>
+    <title><![CDATA[${escapeCdata(siteTitle)}]]></title>
+    <link>${escapeXml(baseUrl)}</link>
+    <description><![CDATA[${escapeCdata(resolveLocale(siteConfig.description))}]]></description>
+    <language>${siteConfig.i18n.defaultLocale}</language>
+    <lastBuildDate>${lastBuildDate}</lastBuildDate>
+    <atom:link href="${escapeXml(selfUrl)}" rel="self" type="application/rss+xml" />${imageXml}
+    ${rssItemsXml}
+  </channel>
+</rss>`;
+
+  return new Response(rssXml, {
+    headers: {
+      'Content-Type': 'application/rss+xml; charset=utf-8',
+      'Cache-Control': 'public, max-age=3600',
+    },
+  });
+}
+
+export function generateAtomFeed(feedType: FeedType, selfUrlPath: string): Response {
+  const { format, content: contentMode } = siteConfig.feed;
+  if (format === 'rss') {
+    return new Response('Not Found', { status: 404 });
+  }
+
+  const baseUrl = siteConfig.baseUrl.replace(/\/+$/, '');
+  const useFullContent = contentMode === 'full';
+  const items = getFeedItems(feedType, useFullContent);
+  const feedUpdated = items[0]?.date.toISOString() ?? new Date().toISOString();
+
+  const selfUrl = `${baseUrl}${selfUrlPath}`;
+
+  const hasAllAuthors = items.every(item => item.authors && item.authors.length > 0);
+  const siteTitle = resolveLocale(siteConfig.title);
+  const defaultAuthor = siteConfig.posts?.authors?.default?.[0];
+  const feedAuthorName = defaultAuthor ? defaultAuthor : siteTitle;
+  const feedAuthorXml = hasAllAuthors ? '' : `\n  <author><name>${escapeXml(feedAuthorName)}</name></author>`;
+
+  const entriesXml = items
+    .map((item) => {
+      const contentXml = useFullContent
+        ? `<content type="html"><![CDATA[${escapeCdata(item.content)}]]></content>\n    <summary><![CDATA[${escapeCdata(item.excerpt)}]]></summary>`
+        : `<summary><![CDATA[${escapeCdata(item.excerpt)}]]></summary>`;
+      const authorsXml = item.authors?.map((a) => `<author><name>${escapeXml(a)}</name></author>`).join('') ?? '';
+      const categoriesXml = item.tags.map((tag) => `<category term="${escapeXml(tag)}" />`).join('');
+      return `
+  <entry>
+    <title><![CDATA[${escapeCdata(item.title)}]]></title>
+    <link href="${escapeXml(item.url)}" />
+    <id>${escapeXml(item.url)}</id>
+    <published>${item.date.toISOString()}</published>
+    <updated>${item.date.toISOString()}</updated>
+    ${contentXml}
+    ${authorsXml}
+    ${categoriesXml}
+  </entry>`;
+    })
+    .join('');
+
+  const atomXml = `<?xml version="1.0" encoding="UTF-8" ?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <title><![CDATA[${escapeCdata(resolveLocale(siteConfig.title))}]]></title>
+  <link href="${escapeXml(baseUrl)}" />
+  <link href="${escapeXml(selfUrl)}" rel="self" type="application/atom+xml" />
+  <id>${escapeXml(selfUrl)}</id>
+  <updated>${feedUpdated}</updated>
+  <subtitle><![CDATA[${escapeCdata(resolveLocale(siteConfig.description))}]]></subtitle>${feedAuthorXml}
+${entriesXml}
+</feed>`;
+
+  return new Response(atomXml, {
+    headers: {
+      'Content-Type': 'application/atom+xml; charset=utf-8',
+      'Cache-Control': 'public, max-age=3600',
+    },
+  });
+}

package/src/lib/markdown.ts

@@ -883,19 +883,30 @@ export function getCollectionPosts(collectionSlug: string): PostData[] {
   const data = getSeriesData(collectionSlug);
   if (data?.type !== 'collection' || !data.items) return [];
 
+  const getCollectionKey = (post: PostData) =>
+    post.series ? `${post.series}/${post.slug}` : `posts/${post.slug}`;
+
+  const allPosts = getAllPosts();
+  const postIndex = new Map(allPosts.map((post) => [getCollectionKey(post), post]));
   const seen = new Set<string>();
+
   return data.items
     .flatMap(item => {
       if ('series' in item) {
         const posts = getSeriesPosts(item.series);
         return item.exclude ? posts.filter(p => !item.exclude!.includes(p.slug)) : posts;
       }
-      const post = getPostBySlug(item.post);
+
+      const post = item.post.includes('/')
+        ? postIndex.get(item.post)
+        : getPostBySlug(item.post);
+
       return post ? [post] : [];
     })
     .filter(post => {
-      if (seen.has(post.slug)) return false;
-      seen.add(post.slug);
+      const key = getCollectionKey(post);
+      if (seen.has(key)) return false;
+      seen.add(key);
       return true;
     });
 }
@@ -1185,6 +1196,7 @@ function parseFlowFile(fullPath: string, slug: string): FlowData {
   }
   const data = parsed.data;
 
+  const h1Match = content.match(/^\s*#\s+(.+)/);
   const contentWithoutH1 = content.replace(/^\s*#\s+[^\n]+/, '').trim();
   const date = data.date || slug.replace(/\//g, '-'); // slug is YYYY/MM/DD, convert to YYYY-MM-DD
   const excerpt = generateExcerpt(contentWithoutH1);
@@ -1193,7 +1205,7 @@ function parseFlowFile(fullPath: string, slug: string): FlowData {
   return {
     slug,
     date,
-    title: data.title ?? date, // fall back to date string if no title in frontmatter
+    title: data.title?.trim() || h1Match?.[1]?.trim() || date, // frontmatter(non-empty) → H1 → date
     tags: data.tags,
     draft: data.draft,
     commentable: data.commentable,

package/tests/e2e/navigation.test.ts

@@ -1,4 +1,5 @@
 import { describe, test, expect } from "bun:test";
+import { siteConfig } from "../../site.config";
 
 const BASE_URL = "http://localhost:3000";
 
@@ -54,6 +55,7 @@ describe("E2E: Navigation & Assets", () => {
 
   test("feed.atom should be a valid Atom feed", async () => {
     if (!(await isServerRunning())) return;
+    if (siteConfig.feed.format === "rss") return; // skip if Atom is disabled
 
     const response = await fetch(`${BASE_URL}/feed.atom`);
     expect(response.status).toBe(200);
@@ -62,4 +64,28 @@ describe("E2E: Navigation & Assets", () => {
     expect(text).toContain('xmlns="http://www.w3.org/2005/Atom"');
     expect(text).toContain("<entry>");
   });
+
+  test("type-specific feeds should be accessible", async () => {
+    if (!(await isServerRunning())) return;
+
+    const feedUrls = [
+      "/posts/feed.xml",
+      "/flows/feed.xml",
+      "/all.xml",
+    ];
+
+    if (siteConfig.feed.format === "atom" || siteConfig.feed.format === "both") {
+      feedUrls.push(
+        "/posts/feed.atom",
+        "/flows/feed.atom",
+        "/all.atom"
+      );
+    }
+
+    for (const url of feedUrls) {
+      const response = await fetch(`${BASE_URL}${url}`);
+      expect(response.status).toBe(200);
+      expect(response.headers.get("content-type")).toContain("xml");
+    }
+  });
 });

package/tests/integration/collections.test.ts

@@ -44,6 +44,21 @@ describe("Integration: Collections", () => {
     expect(slugs).toContain("understanding-react-hooks");
   });
 
+  test("getCollectionPosts resolves namespaced post entries properly", () => {
+    // The modern-web-dev collection uses the "posts/asynchronous-javascript" syntax.
+    // This test ensures that the namespaced resolution logic successfully found it.
+    const posts = getCollectionPosts("modern-web-dev");
+    const foundPost = posts.find(p => p.slug === "asynchronous-javascript");
+    expect(foundPost).toBeDefined();
+    // Because the namespace was "posts/", its series should be undefined
+    expect(foundPost!.series).toBeUndefined();
+
+    // Also verify series-based namespace
+    const seriesPost = posts.find(p => p.slug === "02-architecture");
+    expect(seriesPost).toBeDefined();
+    expect(seriesPost!.series).toBe("digital-garden");
+  });
+
   test("getCollectionPosts includes posts from referenced series", () => {
     const posts = getCollectionPosts("modern-web-dev");
     const slugs = posts.map((p) => p.slug);
@@ -108,8 +123,8 @@ describe("Integration: Collections", () => {
   test("getAllSeries includes collection with correct post count", () => {
     const all = getAllSeries();
     expect(all).toHaveProperty("modern-web-dev");
-    // modern-web-dev has 2 standalone posts + 2 from nextjs-deep-dive
-    expect(all["modern-web-dev"].length).toBe(4);
+    // modern-web-dev has 2 standalone posts + 4 from nextjs-deep-dive
+    expect(all["modern-web-dev"].length).toBe(6);
   });
 
   test("getAllSeries collection posts are sorted by date descending", () => {

package/tests/integration/feed-utils.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import { getFeedItems } from "../../src/lib/feed-utils";
 import { getAllPosts, getAllFlows } from "../../src/lib/markdown";
+import { getPostUrl, getFlowUrl } from "../../src/lib/urls";
 import { siteConfig } from "../../site.config";
 
 describe("Integration: Feed Utils", () => {
@@ -142,4 +143,55 @@ describe("Integration: Feed Utils", () => {
       }
     });
   });
+
+  test("feedType 'posts' returns only post items", () => {
+    const originalMaxItems = siteConfig.feed.maxItems;
+    try {
+      siteConfig.feed.maxItems = 0;
+      const items = getFeedItems('posts');
+      const allPosts = getAllPosts();
+      const baseUrl = siteConfig.baseUrl.replace(/\/+$/, "");
+      expect(items.length).toBe(allPosts.length);
+      expect(items.map((item) => item.url).sort()).toEqual(
+        allPosts.map((post) => `${baseUrl}${getPostUrl(post)}`).sort()
+      );
+    } finally {
+      siteConfig.feed.maxItems = originalMaxItems;
+    }
+  });
+
+  test("feedType 'flows' returns only flow items", () => {
+    const originalMaxItems = siteConfig.feed.maxItems;
+    try {
+      siteConfig.feed.maxItems = 0;
+      const items = getFeedItems('flows');
+      const allFlows = getAllFlows();
+      const baseUrl = siteConfig.baseUrl.replace(/\/+$/, "");
+      expect(items.length).toBe(allFlows.length);
+      expect(items.map((item) => item.url).sort()).toEqual(
+        allFlows.map((flow) => `${baseUrl}${getFlowUrl(flow.slug)}`).sort()
+      );
+    } finally {
+      siteConfig.feed.maxItems = originalMaxItems;
+    }
+  });
+
+  test("feedType 'all' returns both post and flow items", () => {
+    const originalMaxItems = siteConfig.feed.maxItems;
+    try {
+      siteConfig.feed.maxItems = 0;
+      const items = getFeedItems('all');
+      const allPosts = getAllPosts();
+      const allFlows = getAllFlows();
+      const baseUrl = siteConfig.baseUrl.replace(/\/+$/, "");
+      expect(items.map((item) => item.url).sort()).toEqual(
+        [
+          ...allPosts.map((post) => `${baseUrl}${getPostUrl(post)}`),
+          ...allFlows.map((flow) => `${baseUrl}${getFlowUrl(flow.slug)}`),
+        ].sort()
+      );
+    } finally {
+      siteConfig.feed.maxItems = originalMaxItems;
+    }
+  });
 });

package/tests/integration/flow-title.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test";
+import { getFlowBySlug, getAllFlows } from "../../src/lib/markdown";
+
+describe("Integration: Flow Title Resolution", () => {
+  test("frontmatter title takes priority over H1 and date", () => {
+    // content/flows/2026/03/05.md has `title: 'JSDoc type comments'` in frontmatter
+    const flow = getFlowBySlug("2026/03/05");
+    expect(flow).not.toBeNull();
+    expect(flow!.title).toBe("JSDoc type comments");
+  });
+
+  test("H1 heading is extracted as title when no frontmatter title", () => {
+    // content/flows/2026/03/07.md has no frontmatter title but has `# Using Claude Code`
+    const flow = getFlowBySlug("2026/03/07");
+    expect(flow).not.toBeNull();
+    expect(flow!.title).toBe("Using Claude Code");
+  });
+
+  test("date is used as fallback when no frontmatter title or H1", () => {
+    // content/flows/2026/02/05.md has no title and no H1
+    const flow = getFlowBySlug("2026/02/05");
+    expect(flow).not.toBeNull();
+    expect(flow!.title).toBe("2026-02-05");
+  });
+
+  test("H1 heading is stripped from content body", () => {
+    const flow = getFlowBySlug("2026/03/07");
+    expect(flow).not.toBeNull();
+    // The H1 should be extracted as title but removed from content
+    expect(flow!.content).not.toMatch(/^#\s+Using Claude Code/m);
+    // The body content should still be present
+    expect(flow!.content).toContain("Claude Code");
+  });
+
+  test("every flow has a non-empty title", () => {
+    const flows = getAllFlows();
+    expect(flows.length).toBeGreaterThan(0);
+    flows.forEach((flow) => {
+      expect(flow.title).toBeTruthy();
+      expect(flow.title.trim().length).toBeGreaterThan(0);
+    });
+  });
+
+  test("flow with frontmatter title preserves content H1 independently", () => {
+    // content/flows/2026/03/05.md has frontmatter title — any H1 in content
+    // should still be stripped, but title comes from frontmatter
+    const flow = getFlowBySlug("2026/03/05");
+    expect(flow).not.toBeNull();
+    expect(flow!.title).toBe("JSDoc type comments");
+    // Content should not start with an H1
+    expect(flow!.content).not.toMatch(/^\s*#\s+/);
+  });
+});