@hutusi/amytis 1.7.0 → 1.9.0

package/src/lib/markdown.ts

@@ -10,6 +10,7 @@ const pagesDirectory = path.join(process.cwd(), 'content');
 const seriesDirectory = path.join(process.cwd(), 'content', 'series');
 const booksDirectory = path.join(process.cwd(), 'content', 'books');
 const flowsDirectory = path.join(process.cwd(), 'content', 'flows');
+const notesDirectory = path.join(process.cwd(), 'content', 'notes');
 
 const ExternalLinkSchema = z.object({
   name: z.string(),
@@ -98,7 +99,7 @@ export function generateExcerpt(content: string): string {
   plain = plain.replace(/!\[[^\]]*\]\([^)]+\)/g, '');
   plain = plain.replace(/\*\[([^\]]+)\*\]\([^)]+\)/g, '$1');
   plain = plain.replace(/(\$\*\*|__|\*|_)/g, '');
-  plain = plain.replace(/`[^`]*`/g, '');
+  plain = plain.replace(/`([^`]+)`/g, '$1');
   plain = plain.replace(/^>\s+/gm, '');
   plain = plain.replace(/\s+/g, ' ').trim();
   
@@ -549,6 +550,7 @@ export function getFlowTags(): Record<string, number> {
 export function getAllTags(): Record<string, number> {
   const allPosts = getAllPosts();
   const allFlows = getAllFlows();
+  const allNotes = getAllNotes();
   const tags: Record<string, number> = {};
 
   allPosts.forEach((post) => {
@@ -565,6 +567,13 @@ export function getAllTags(): Record<string, number> {
     });
   });
 
+  allNotes.forEach((note) => {
+    note.tags.forEach((tag) => {
+      const normalizedTag = tag.toLowerCase();
+      tags[normalizedTag] = (tags[normalizedTag] || 0) + 1;
+    });
+  });
+
   return tags;
 }
 
@@ -577,7 +586,12 @@ export function getPostsByAuthor(author: string): PostData[] {
 
 export function getAuthorSlug(author: string): string {
   const slugger = new GithubSlugger();
-  return slugger.slug(author.trim());
+  // Normalize all Unicode dash punctuation to ASCII hyphen, then trim edges.
+  // This avoids runtime-specific outputs like wrapped dash variants.
+  return slugger
+    .slug(author.trim())
+    .replace(/[\p{Dash_Punctuation}]+/gu, '-')
+    .replace(/^-+|-+$/g, '');
 }
 
 export function getAllAuthors(): Record<string, number> {
@@ -745,15 +759,15 @@ export function getSeriesData(slug: string): PostData | null {
 
 export interface BookChapterEntry {
   title: string;
-  file: string;
+  id: string;
   part?: string;
 }
 
 export interface BookTocPart {
   part: string;
-  chapters: { title: string; file: string }[];
+  chapters: { title: string; id: string }[];
 }
-export type BookTocItem = BookTocPart | { title: string; file: string };
+export type BookTocItem = BookTocPart | { title: string; id: string };
 
 export interface BookData {
   title: string;
@@ -778,13 +792,14 @@ export interface BookChapterData {
   excerpt?: string;
   latex: boolean;
   readingTime: string;
-  prevChapter: { title: string; file: string } | null;
-  nextChapter: { title: string; file: string } | null;
+  isFolder: boolean;
+  prevChapter: { title: string; id: string } | null;
+  nextChapter: { title: string; id: string } | null;
 }
 
 const BookChapterRefSchema = z.object({
   title: z.string(),
-  file: z.string(),
+  id: z.string(),
 });
 
 const BookTocItemSchema: z.ZodType<BookTocItem> = z.union([
@@ -818,10 +833,10 @@ function flattenBookChapters(toc: BookTocItem[]): BookChapterEntry[] {
   for (const item of toc) {
     if ('part' in item) {
       for (const ch of item.chapters) {
-        result.push({ title: ch.title, file: ch.file, part: item.part });
+        result.push({ title: ch.title, id: ch.id, part: item.part });
       }
     } else {
-      result.push({ title: item.title, file: item.file });
+      result.push({ title: item.title, id: item.id });
     }
   }
   return result;
@@ -852,10 +867,12 @@ export function getBookData(slug: string): BookData | null {
   // Warn about missing chapter files
   const chapters = flattenBookChapters(data.chapters);
   for (const ch of chapters) {
-    const chMdx = path.join(bookDir, `${ch.file}.mdx`);
-    const chMd = path.join(bookDir, `${ch.file}.md`);
-    if (!fs.existsSync(chMdx) && !fs.existsSync(chMd)) {
-      console.warn(`Book "${slug}": chapter file "${ch.file}" not found`);
+    const chMdx = path.join(bookDir, `${ch.id}.mdx`);
+    const chMd = path.join(bookDir, `${ch.id}.md`);
+    const chFolderMdx = path.join(bookDir, ch.id, 'index.mdx');
+    const chFolderMd = path.join(bookDir, ch.id, 'index.md');
+    if (!fs.existsSync(chMdx) && !fs.existsSync(chMd) && !fs.existsSync(chFolderMdx) && !fs.existsSync(chFolderMd)) {
+      console.warn(`Book "${slug}": chapter "${ch.id}" not found`);
     }
   }
 
@@ -892,9 +909,14 @@ export function getBookChapter(bookSlug: string, chapterSlug: string): BookChapt
   const bookDir = path.join(booksDirectory, bookSlug);
   const chMdx = path.join(bookDir, `${chapterSlug}.mdx`);
   const chMd = path.join(bookDir, `${chapterSlug}.md`);
+  const chFolderMdx = path.join(bookDir, chapterSlug, 'index.mdx');
+  const chFolderMd = path.join(bookDir, chapterSlug, 'index.md');
   let fullPath = '';
+  let isFolder = false;
   if (fs.existsSync(chMdx)) fullPath = chMdx;
   else if (fs.existsSync(chMd)) fullPath = chMd;
+  else if (fs.existsSync(chFolderMdx)) { fullPath = chFolderMdx; isFolder = true; }
+  else if (fs.existsSync(chFolderMd)) { fullPath = chFolderMd; isFolder = true; }
   else return null;
 
   const fileContents = fs.readFileSync(fullPath, 'utf8');
@@ -917,7 +939,7 @@ export function getBookChapter(bookSlug: string, chapterSlug: string): BookChapt
   const excerpt = data.excerpt || generateExcerpt(contentWithoutH1);
 
   // Find prev/next
-  const chapterIndex = book.chapters.findIndex(ch => ch.file === chapterSlug);
+  const chapterIndex = book.chapters.findIndex(ch => ch.id === chapterSlug);
   const prevChapter = chapterIndex > 0 ? book.chapters[chapterIndex - 1] : null;
   const nextChapter = chapterIndex < book.chapters.length - 1 ? book.chapters[chapterIndex + 1] : null;
 
@@ -930,8 +952,9 @@ export function getBookChapter(bookSlug: string, chapterSlug: string): BookChapt
     excerpt,
     latex: data.latex,
     readingTime,
-    prevChapter: prevChapter ? { title: prevChapter.title, file: prevChapter.file } : null,
-    nextChapter: nextChapter ? { title: nextChapter.title, file: nextChapter.file } : null,
+    isFolder,
+    prevChapter: prevChapter ? { title: prevChapter.title, id: prevChapter.id } : null,
+    nextChapter: nextChapter ? { title: nextChapter.title, id: nextChapter.id } : null,
   };
 }
 
@@ -965,7 +988,7 @@ export function getBooksByAuthor(author: string): BookData[] {
 // ─── Flows (Daily Notes) ────────────────────────────────────────────────────
 
 const FlowSchema = z.object({
-  title: z.string(),
+  title: z.string().optional(),
   date: z.union([z.string(), z.date()]).transform(val => new Date(val).toISOString().split('T')[0]).optional(),
   tags: z.array(z.string()).optional().default([]),
   draft: z.boolean().optional().default(false),
@@ -1001,7 +1024,7 @@ function parseFlowFile(fullPath: string, slug: string): FlowData {
   return {
     slug,
     date,
-    title: data.title,
+    title: data.title ?? date, // fall back to date string if no title in frontmatter
     tags: data.tags,
     draft: data.draft,
     content: contentWithoutH1,
@@ -1121,3 +1144,267 @@ export function getAdjacentFlows(slug: string): { prev: FlowData | null; next: F
 export function getRecentFlows(limit: number = 5): FlowData[] {
   return getAllFlows().slice(0, limit);
 }
+
+// ─── Notes (Knowledge Base) ──────────────────────────────────────────────────
+
+const NoteSchema = z.object({
+  title: z.string(),
+  date: z.union([z.string(), z.date()]).transform(val => new Date(val).toISOString().split('T')[0]).optional(),
+  tags: z.array(z.string()).optional().default([]),
+  draft: z.boolean().optional().default(false),
+  aliases: z.array(z.string()).optional().default([]),
+  toc: z.boolean().optional().default(true),
+  backlinks: z.boolean().optional().default(true),
+});
+
+export interface NoteData {
+  slug: string;
+  title: string;
+  date: string;
+  tags: string[];
+  draft: boolean;
+  aliases: string[];
+  toc: boolean;
+  backlinks: boolean;
+  content: string;
+  excerpt: string;
+  headings: Heading[];
+  readingTime: string;
+}
+
+function parseNoteFile(fullPath: string, slug: string): NoteData {
+  const fileContents = fs.readFileSync(fullPath, 'utf8');
+  const { data: rawData, content } = matter(fileContents);
+
+  const parsed = NoteSchema.safeParse(rawData);
+  if (!parsed.success) {
+    console.error(`Invalid note frontmatter in ${fullPath}:`, parsed.error.format());
+    throw new Error(`Invalid note frontmatter in ${fullPath}`);
+  }
+  const data = parsed.data;
+
+  const contentWithoutH1 = content.replace(/^\s*#\s+[^\n]+/, '').trim();
+  const date = data.date || fs.statSync(fullPath).mtime.toISOString().split('T')[0];
+  const excerpt = generateExcerpt(contentWithoutH1);
+  const headings = getHeadings(content);
+  const readingTime = calculateReadingTime(contentWithoutH1);
+
+  return {
+    slug,
+    title: data.title,
+    date,
+    tags: data.tags,
+    draft: data.draft,
+    aliases: data.aliases,
+    toc: data.toc,
+    backlinks: data.backlinks,
+    content: contentWithoutH1,
+    excerpt,
+    headings,
+    readingTime,
+  };
+}
+
+let _allNotes: NoteData[] | null = null;
+
+export function getAllNotes(): NoteData[] {
+  if (_allNotes && process.env.NODE_ENV === 'production') return _allNotes;
+
+  if (!fs.existsSync(notesDirectory)) {
+    _allNotes = [];
+    return _allNotes;
+  }
+
+  const notes: NoteData[] = [];
+  const items = fs.readdirSync(notesDirectory, { withFileTypes: true });
+
+  for (const item of items) {
+    if (!item.isFile()) continue;
+    if (!item.name.endsWith('.md') && !item.name.endsWith('.mdx')) continue;
+    const slug = item.name.replace(/\.mdx?$/, '');
+    const fullPath = path.join(notesDirectory, item.name);
+    try {
+      notes.push(parseNoteFile(fullPath, slug));
+    } catch (e) {
+      console.error(`Error parsing note ${fullPath}:`, e);
+    }
+  }
+
+  _allNotes = notes
+    .filter(note => process.env.NODE_ENV !== 'production' || !note.draft)
+    .sort((a, b) => (a.date < b.date ? 1 : -1));
+
+  return _allNotes;
+}
+
+export function getNoteBySlug(slug: string): NoteData | null {
+  if (!fs.existsSync(notesDirectory)) return null;
+
+  const mdxPath = path.join(notesDirectory, `${slug}.mdx`);
+  const mdPath = path.join(notesDirectory, `${slug}.md`);
+
+  let fullPath = '';
+  if (fs.existsSync(mdxPath)) fullPath = mdxPath;
+  else if (fs.existsSync(mdPath)) fullPath = mdPath;
+  else return null;
+
+  try {
+    const note = parseNoteFile(fullPath, slug);
+    if (process.env.NODE_ENV === 'production' && note.draft) return null;
+    return note;
+  } catch {
+    return null;
+  }
+}
+
+export function getAdjacentNotes(slug: string): { prev: NoteData | null; next: NoteData | null } {
+  const allNotes = getAllNotes(); // sorted newest-first
+  const index = allNotes.findIndex(n => n.slug === slug);
+  if (index === -1) return { prev: null, next: null };
+  return {
+    prev: index < allNotes.length - 1 ? allNotes[index + 1] : null, // older
+    next: index > 0 ? allNotes[index - 1] : null, // newer
+  };
+}
+
+export function getRecentNotes(limit: number = 5): NoteData[] {
+  return getAllNotes().slice(0, limit);
+}
+
+export function getNoteTags(): Record<string, number> {
+  const tags: Record<string, number> = {};
+  getAllNotes().forEach(note => {
+    note.tags.forEach(tag => {
+      const normalized = tag.toLowerCase();
+      tags[normalized] = (tags[normalized] || 0) + 1;
+    });
+  });
+  return tags;
+}
+
+export function getNotesByTag(tag: string): NoteData[] {
+  return getAllNotes().filter(n =>
+    n.tags.map(t => t.toLowerCase()).includes(tag.toLowerCase())
+  );
+}
+
+// ─── Slug Registry ───────────────────────────────────────────────────────────
+
+export interface SlugRegistryEntry {
+  url: string;
+  type: 'post' | 'note' | 'flow' | 'series';
+  title: string;
+}
+
+let _slugRegistry: Map<string, SlugRegistryEntry> | null = null;
+
+export function buildSlugRegistry(): Map<string, SlugRegistryEntry> {
+  if (_slugRegistry && process.env.NODE_ENV === 'production') return _slugRegistry;
+
+  const map = new Map<string, SlugRegistryEntry>();
+
+  getAllPosts().forEach(p =>
+    map.set(p.slug, { url: `/posts/${p.slug}`, type: 'post', title: p.title })
+  );
+
+  getAllFlows().forEach(f =>
+    map.set(f.slug, { url: `/flows/${f.slug}`, type: 'flow', title: f.title })
+  );
+
+  getAllNotes().forEach(n => {
+    if (map.has(n.slug)) {
+      console.warn(`[slugRegistry] Note slug "${n.slug}" conflicts with an existing entry.`);
+    }
+    map.set(n.slug, { url: `/notes/${n.slug}`, type: 'note', title: n.title });
+    n.aliases.forEach(a => {
+      if (map.has(a)) {
+        console.warn(`[slugRegistry] Note alias "${a}" (→ ${n.slug}) conflicts with existing slug; skipping.`);
+      } else {
+        map.set(a, { url: `/notes/${n.slug}`, type: 'note', title: n.title });
+      }
+    });
+  });
+
+  if (fs.existsSync(seriesDirectory)) {
+    fs.readdirSync(seriesDirectory, { withFileTypes: true }).forEach(entry => {
+      if (!entry.isDirectory()) return;
+      const slug = entry.name;
+      const seriesData = getSeriesData(slug);
+      map.set(slug, {
+        url: `/series/${slug}`,
+        type: 'series',
+        title: seriesData?.title || slug,
+      });
+    });
+  }
+
+  _slugRegistry = map;
+  return map;
+}
+
+// ─── Backlink Index ──────────────────────────────────────────────────────────
+
+export interface BacklinkSource {
+  slug: string;
+  title: string;
+  type: 'post' | 'note' | 'flow' | 'series';
+  url: string;
+  context: string;
+}
+
+function extractWikilinkContext(text: string, matchStart: number, matchEnd: number): string {
+  const RADIUS = 120;
+  const start = Math.max(0, matchStart - RADIUS);
+  const end = Math.min(text.length, matchEnd + RADIUS);
+  let ctx = text.slice(start, end);
+
+  // Replace wikilinks in context with just display text for readability
+  ctx = ctx.replace(/\[\[([^\]|]+?)(?:\|([^\]]+?))?\]\]/g, (_, slug, display) => display || slug);
+
+  if (start > 0) ctx = ctx.replace(/^[^\s.!?]{1,30}/, '').trimStart();
+  if (end < text.length) ctx = ctx.replace(/[^\s.!?]{1,30}$/, '').trimEnd();
+
+  return ctx.trim().slice(0, 200);
+}
+
+function buildBacklinkIndex(): Map<string, BacklinkSource[]> {
+  const index = new Map<string, BacklinkSource[]>();
+
+  const addBacklinks = (
+    content: string,
+    sourceSlug: string,
+    sourceTitle: string,
+    sourceType: BacklinkSource['type'],
+    sourceUrl: string
+  ) => {
+    // Create a fresh RegExp per call to avoid lastIndex issues with 'g' flag
+    const WIKILINK = /\[\[([^\]|]+?)(?:\|([^\]]+?))?\]\]/g;
+    let match;
+    while ((match = WIKILINK.exec(content)) !== null) {
+      const targetSlug = match[1].trim();
+      if (targetSlug === sourceSlug) continue; // skip self-references
+      const context = extractWikilinkContext(content, match.index, match.index + match[0].length);
+      let sources = index.get(targetSlug);
+      if (!sources) {
+        sources = [];
+        index.set(targetSlug, sources);
+      }
+      if (!sources.some(b => b.slug === sourceSlug && b.type === sourceType)) {
+        sources.push({ slug: sourceSlug, title: sourceTitle, type: sourceType, url: sourceUrl, context });
+      }
+    }
+  };
+
+  getAllPosts().forEach(p => addBacklinks(p.content, p.slug, p.title, 'post', `/posts/${p.slug}`));
+  getAllNotes().forEach(n => addBacklinks(n.content, n.slug, n.title, 'note', `/notes/${n.slug}`));
+  getAllFlows().forEach(f => addBacklinks(f.content, f.slug, f.title, 'flow', `/flows/${f.slug}`));
+
+  return index;
+}
+
+let _backlinkIndex: Map<string, BacklinkSource[]> | null = null;
+
+export function getBacklinks(slug: string): BacklinkSource[] {
+  if (!_backlinkIndex || process.env.NODE_ENV !== 'production') _backlinkIndex = buildBacklinkIndex();
+  return _backlinkIndex.get(slug) ?? [];
+}

package/src/lib/remark-wikilinks.ts

@@ -0,0 +1,59 @@
+import { visit } from 'unist-util-visit';
+import type { Root, Text, Parent } from 'mdast';
+import type { SlugRegistryEntry } from './markdown';
+
+interface WikilinksOptions {
+  slugRegistry: Map<string, SlugRegistryEntry>;
+}
+
+export default function remarkWikilinks({ slugRegistry }: WikilinksOptions) {
+  return (tree: Root) => {
+    visit(tree, 'text', (node: Text, index: number | undefined, parent: Parent | undefined) => {
+      if (!parent || index === undefined) return;
+      if (!node.value.includes('[[')) return;
+
+      // Create fresh regex each time to avoid lastIndex issue with 'g' flag
+      const WIKILINK = /\[\[([^\]|]+?)(?:\|([^\]]+?))?\]\]/g;
+      if (!WIKILINK.test(node.value)) return;
+      WIKILINK.lastIndex = 0;
+
+      const newNodes: (Text | { type: 'html'; value: string })[] = [];
+      let last = 0;
+      let match: RegExpExecArray | null;
+
+      while ((match = WIKILINK.exec(node.value)) !== null) {
+        if (match.index > last) {
+          newNodes.push({ type: 'text', value: node.value.slice(last, match.index) });
+        }
+
+        const slug = match[1].trim();
+        const display = match[2]?.trim() || slug;
+        const entry = slugRegistry.get(slug);
+
+        if (entry) {
+          newNodes.push({
+            type: 'html',
+            value: `<a href="${entry.url}" class="wikilink wikilink--resolved wikilink--${entry.type}">${display}</a>`,
+          });
+        } else {
+          newNodes.push({
+            type: 'html',
+            value: `<span class="wikilink wikilink--broken" title="[[${slug}]] not found">${display}</span>`,
+          });
+        }
+
+        last = match.index + match[0].length;
+      }
+
+      if (last < node.value.length) {
+        newNodes.push({ type: 'text', value: node.value.slice(last) });
+      }
+
+      if (newNodes.length > 1 || (newNodes.length === 1 && newNodes[0].type !== 'text')) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (parent.children as any[]).splice(index, 1, ...newNodes);
+        return index + newNodes.length; // skip inserted nodes
+      }
+    });
+  };
+}

package/src/lib/search-utils.ts

@@ -1,9 +1,10 @@
-export type ContentType = 'All' | 'Post' | 'Flow' | 'Book';
+export type ContentType = 'All' | 'Post' | 'Flow' | 'Book' | 'Note';
 
 /** Derive content type from a Pagefind result URL. */
 export function getResultType(url: string): Exclude<ContentType, 'All'> {
   if (url.includes('/flows/')) return 'Flow';
   if (url.includes('/books/')) return 'Book';
+  if (url.includes('/notes/')) return 'Note';
   return 'Post';
 }