@hutusi/amytis 1.7.0 → 1.8.0

package/src/i18n/translations.ts

@@ -60,7 +60,7 @@ export const translations = {
     selected_books: "Selected Books",
     flow: "Flow",
     recent_notes: "Recent Notes",
-    all_flows: "All Notes",
+    all_flows: "All Flows",
     no_flows: "No notes yet.",
     flow_subtitle: "{count} daily notes.",
     flows_in_year: "Notes in {year}",
@@ -117,6 +117,16 @@ export const translations = {
     sort_az: "A–Z",
     tags_count: "{shown} / {total} tags",
     tags_no_match: "No tags match \"{filter}\"",
+    notes: "Notes",
+    notes_subtitle: "{count} knowledge base notes.",
+    tab_daily_flow: "Daily",
+    tab_graph: "Graph",
+    backlinks: "Backlinks",
+    graph_subtitle: "A visual map of connected knowledge.",
+    search_type_note: "Note",
+    all_notes: "All Notes",
+    no_notes: "No notes yet.",
+    more: "More",
   },
   zh: {
     home: "首页",
@@ -236,6 +246,16 @@ export const translations = {
     sort_az: "A–Z",
     tags_count: "{shown} / {total} 个标签",
     tags_no_match: "未找到匹配\"{filter}\"的标签",
+    notes: "笔记",
+    notes_subtitle: "共 {count} 条知识库笔记。",
+    tab_daily_flow: "随笔",
+    tab_graph: "图谱",
+    backlinks: "反向链接",
+    graph_subtitle: "知识连接的可视化地图。",
+    search_type_note: "笔记",
+    all_notes: "全部笔记",
+    no_notes: "暂无笔记。",
+    more: "更多",
   },
 };
 

package/src/layouts/PostLayout.tsx

@@ -1,11 +1,12 @@
 import Link from 'next/link';
-import { getAuthorSlug, PostData } from '@/lib/markdown';
+import { getAuthorSlug, PostData, BacklinkSource, SlugRegistryEntry } from '@/lib/markdown';
 import MarkdownRenderer from '@/components/MarkdownRenderer';
 import RelatedPosts from '@/components/RelatedPosts';
 import SeriesList from '@/components/SeriesList';
 import PostSidebar from '@/components/PostSidebar';
 import Comments from '@/components/Comments';
 import ExternalLinks from '@/components/ExternalLinks';
+import Backlinks from '@/components/Backlinks';
 import Tag from '@/components/Tag';
 import ReadingProgressBar from '@/components/ReadingProgressBar';
 import PostNavigation from '@/components/PostNavigation';
@@ -21,9 +22,11 @@ interface PostLayoutProps {
   seriesTitle?: string;
   prevPost?: PostData | null;
   nextPost?: PostData | null;
+  backlinks?: BacklinkSource[];
+  slugRegistry?: Map<string, SlugRegistryEntry>;
 }
 
-export default function PostLayout({ post, relatedPosts, seriesPosts, seriesTitle, prevPost, nextPost }: PostLayoutProps) {
+export default function PostLayout({ post, relatedPosts, seriesPosts, seriesTitle, prevPost, nextPost, backlinks, slugRegistry }: PostLayoutProps) {
   const showToc = siteConfig.posts?.toc !== false && post.toc !== false && post.headings && post.headings.length > 0;
   const hasSeries = !!(post.series && seriesPosts && seriesPosts.length > 0);
   const showSidebar = showToc || hasSeries;
@@ -110,7 +113,7 @@ export default function PostLayout({ post, relatedPosts, seriesPosts, seriesTitl
             </div>
           )}
 
-          <MarkdownRenderer content={post.content} latex={post.latex} slug={post.slug} />
+          <MarkdownRenderer content={post.content} latex={post.latex} slug={post.slug} slugRegistry={slugRegistry} />
 
           {post.tags && post.tags.length > 0 && (
             <div className="mt-12 pt-12 border-t border-muted/20 flex flex-wrap items-center gap-2">
@@ -125,6 +128,8 @@ export default function PostLayout({ post, relatedPosts, seriesPosts, seriesTitl
             <ExternalLinks links={post.externalLinks} />
           )}
 
+          <Backlinks backlinks={backlinks ?? []} />
+
           <ShareBar
             url={postUrl}
             title={post.title}

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;
 }
 
@@ -965,7 +974,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 +1010,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 +1130,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';
 }