nuartz 0.1.0

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "nuartz",
+  "version": "0.1.0",
+  "description": "Obsidian-compatible markdown pipeline for Next.js",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/syshin0116/nuartz.git"
+  },
+  "keywords": ["markdown", "obsidian", "nextjs", "blog", "mdx", "remark", "rehype"],
+  "homepage": "https://github.com/syshin0116/nuartz#readme",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "gray-matter": "^4.0.3",
+    "hast-util-to-html": "^9.0.0",
+    "rehype-autolink-headings": "^7.0.0",
+    "rehype-katex": "^7.0.0",
+    "rehype-pretty-code": "^0.14.3",
+    "rehype-raw": "^7.0.0",
+    "rehype-slug": "^6.0.0",
+    "rehype-stringify": "^10.0.0",
+    "remark-breaks": "^4.0.0",
+    "remark-frontmatter": "^5.0.0",
+    "remark-gfm": "^4.0.0",
+    "remark-math": "^6.0.0",
+    "remark-parse": "^11.0.0",
+    "remark-rehype": "^11.0.0",
+    "shiki": "^4.0.1",
+    "unified": "^11.0.0",
+    "unist-util-visit": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "@vitest/coverage-v8": "^4.0.18",
+    "typescript": "^5",
+    "vitest": "^4.0.18"
+  }
+}

package/src/__fixtures__/basic.md

@@ -0,0 +1,20 @@
+# Sample Document
+
+This is a paragraph with a [[Wiki Link]] and a #sample-tag.
+
+> [!note] Important Note
+> This is a callout with some content.
+
+Here is a [[Page|Custom Alias]] and [[Page#Section]] reference.
+
+> [!warning]+ Collapsible Warning
+> This warning is collapsible.
+
+Tags: #javascript #web-dev
+
+![[diagram.png]]
+
+> This is a regular blockquote, not a callout.
+
+> [!tip]- Collapsed Tip
+> Hidden by default.

package/src/__tests__/backlinks.test.ts

@@ -0,0 +1,156 @@
+import { describe, it, expect } from "vitest"
+import { buildBacklinkIndex, getBacklinks } from "../backlinks"
+import type { RenderResult } from "../types"
+
+function mockPage(
+  links: string[],
+  title: string,
+  raw: string
+): { result: RenderResult; raw: string } {
+  return {
+    result: {
+      html: "",
+      frontmatter: { title },
+      toc: [],
+      links,
+      tags: [],
+    },
+    raw,
+  }
+}
+
+describe("buildBacklinkIndex", () => {
+  it("builds index from pages with outgoing links", () => {
+    const pages = new Map([
+      ["page-a", mockPage(["Page B"], "Page A", "Links to Page B")],
+      ["page-b", mockPage(["Page A"], "Page B", "Links to Page A")],
+    ])
+
+    const index = buildBacklinkIndex(pages)
+    // "Page B" normalizes to "page-b"
+    const backlinksForB = index.get("page-b")
+    expect(backlinksForB).toBeDefined()
+    expect(backlinksForB).toHaveLength(1)
+    expect(backlinksForB![0].slug).toBe("page-a")
+    expect(backlinksForB![0].title).toBe("Page A")
+  })
+
+  it("normalizes target slugs: lowercase and spaces to hyphens", () => {
+    const pages = new Map([
+      ["source", mockPage(["My Target Page"], "Source", "Content here")],
+    ])
+
+    const index = buildBacklinkIndex(pages)
+    expect(index.has("my-target-page")).toBe(true)
+  })
+
+  it("strips non-word/non-hyphen characters from target slug", () => {
+    const pages = new Map([
+      ["source", mockPage(["Page (draft)"], "Source", "Content")],
+    ])
+
+    const index = buildBacklinkIndex(pages)
+    // "Page (draft)" -> "page-draft" (parens removed)
+    expect(index.has("page-draft")).toBe(true)
+  })
+
+  it("collects multiple backlinks for the same target", () => {
+    const pages = new Map([
+      ["alpha", mockPage(["Target"], "Alpha", "Alpha links to target")],
+      ["beta", mockPage(["Target"], "Beta", "Beta links to target")],
+      ["gamma", mockPage(["Target"], "Gamma", "Gamma links to target")],
+    ])
+
+    const index = buildBacklinkIndex(pages)
+    const backlinks = index.get("target")
+    expect(backlinks).toHaveLength(3)
+    const slugs = backlinks!.map((b) => b.slug)
+    expect(slugs).toContain("alpha")
+    expect(slugs).toContain("beta")
+    expect(slugs).toContain("gamma")
+  })
+
+  it("generates excerpt from raw content stripping frontmatter", () => {
+    const raw = `---
+title: Source Page
+---
+
+This is the body content that should appear in the excerpt.`
+
+    const pages = new Map([
+      ["source", mockPage(["Target"], "Source Page", raw)],
+    ])
+
+    const index = buildBacklinkIndex(pages)
+    const backlinks = index.get("target")!
+    expect(backlinks[0].excerpt).toContain("This is the body content")
+    expect(backlinks[0].excerpt).not.toContain("---")
+  })
+
+  it("truncates excerpt to 160 characters plus ellipsis", () => {
+    const longBody = "A".repeat(200)
+    const pages = new Map([
+      ["source", mockPage(["Target"], "Source", longBody)],
+    ])
+
+    const index = buildBacklinkIndex(pages)
+    const backlinks = index.get("target")!
+    // 160 chars + ellipsis character
+    expect(backlinks[0].excerpt.length).toBeLessThanOrEqual(161)
+    expect(backlinks[0].excerpt).toMatch(/\u2026$/)
+  })
+
+  it("uses slug as title fallback when no frontmatter title", () => {
+    const pages = new Map([
+      [
+        "no-title-page",
+        {
+          result: {
+            html: "",
+            frontmatter: {},
+            toc: [],
+            links: ["Target"],
+            tags: [],
+          } as RenderResult,
+          raw: "Some content",
+        },
+      ],
+    ])
+
+    const index = buildBacklinkIndex(pages)
+    const backlinks = index.get("target")!
+    expect(backlinks[0].title).toBe("no-title-page")
+  })
+})
+
+describe("getBacklinks", () => {
+  it("returns correct BacklinkEntry[] for known slug", () => {
+    const pages = new Map([
+      ["source", mockPage(["Target"], "Source Title", "Content about target")],
+    ])
+
+    const index = buildBacklinkIndex(pages)
+    const backlinks = getBacklinks(index, "target")
+
+    expect(backlinks).toHaveLength(1)
+    expect(backlinks[0].slug).toBe("source")
+    expect(backlinks[0].title).toBe("Source Title")
+    expect(backlinks[0].excerpt).toBeTruthy()
+  })
+
+  it("returns empty array for unknown slug", () => {
+    const pages = new Map([
+      ["source", mockPage(["Target"], "Source", "Content")],
+    ])
+
+    const index = buildBacklinkIndex(pages)
+    const backlinks = getBacklinks(index, "nonexistent")
+    expect(backlinks).toEqual([])
+  })
+
+  it("returns empty array for empty index", () => {
+    const index = buildBacklinkIndex(new Map())
+    const backlinks = getBacklinks(index, "anything")
+    expect(backlinks).toEqual([])
+  })
+})

package/src/__tests__/fs.test.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest"
+import fs from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { getAllMarkdownFiles, getMarkdownBySlug, buildFileTree } from "../fs"
+import type { MarkdownFile } from "../fs"
+
+describe("getAllMarkdownFiles", () => {
+  let tmpDir: string
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "nuartz-fs-test-"))
+  })
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true })
+  })
+
+  it("returns all .md files recursively", async () => {
+    await fs.writeFile(path.join(tmpDir, "root.md"), "# Root")
+    await fs.mkdir(path.join(tmpDir, "sub"), { recursive: true })
+    await fs.writeFile(path.join(tmpDir, "sub", "nested.md"), "# Nested")
+
+    const files = await getAllMarkdownFiles(tmpDir)
+    const slugs = files.map((f) => f.slug)
+    expect(slugs).toContain("root")
+    expect(slugs).toContain("sub/nested")
+  })
+
+  it("excludes files starting with _", async () => {
+    await fs.writeFile(path.join(tmpDir, "visible.md"), "# Visible")
+    await fs.writeFile(path.join(tmpDir, "_hidden.md"), "# Hidden")
+
+    const files = await getAllMarkdownFiles(tmpDir)
+    const slugs = files.map((f) => f.slug)
+    expect(slugs).toContain("visible")
+    expect(slugs).not.toContain("_hidden")
+  })
+
+  it("returns MarkdownFile[] with correct slug format", async () => {
+    await fs.mkdir(path.join(tmpDir, "notes"), { recursive: true })
+    await fs.writeFile(path.join(tmpDir, "notes", "foo.md"), "# Foo")
+
+    const files = await getAllMarkdownFiles(tmpDir)
+    expect(files).toHaveLength(1)
+    expect(files[0].slug).toBe("notes/foo")
+    expect(files[0].filePath).toBe(path.join(tmpDir, "notes", "foo.md"))
+    expect(files[0].raw).toContain("# Foo")
+  })
+
+  it("parses frontmatter", async () => {
+    const content = `---
+title: My Note
+tags:
+  - test
+---
+
+Body content`
+    await fs.writeFile(path.join(tmpDir, "note.md"), content)
+
+    const files = await getAllMarkdownFiles(tmpDir)
+    expect(files[0].frontmatter.title).toBe("My Note")
+    expect(files[0].frontmatter.tags).toEqual(["test"])
+  })
+
+  it("returns empty array for non-existent directory", async () => {
+    const files = await getAllMarkdownFiles(path.join(tmpDir, "nonexistent"))
+    expect(files).toEqual([])
+  })
+})
+
+describe("getMarkdownBySlug", () => {
+  let tmpDir: string
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "nuartz-slug-test-"))
+  })
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true })
+  })
+
+  it("returns MarkdownFile for existing slug", async () => {
+    const content = `---
+title: Hello
+---
+
+World`
+    await fs.writeFile(path.join(tmpDir, "hello.md"), content)
+
+    const file = await getMarkdownBySlug(tmpDir, "hello")
+    expect(file).not.toBeNull()
+    expect(file!.slug).toBe("hello")
+    expect(file!.frontmatter.title).toBe("Hello")
+    expect(file!.raw).toContain("World")
+  })
+
+  it("returns null for non-existent slug", async () => {
+    const file = await getMarkdownBySlug(tmpDir, "does-not-exist")
+    expect(file).toBeNull()
+  })
+
+  it("works with nested slugs", async () => {
+    await fs.mkdir(path.join(tmpDir, "notes"), { recursive: true })
+    await fs.writeFile(path.join(tmpDir, "notes", "deep.md"), "# Deep")
+
+    const file = await getMarkdownBySlug(tmpDir, "notes/deep")
+    expect(file).not.toBeNull()
+    expect(file!.slug).toBe("notes/deep")
+  })
+})
+
+describe("buildFileTree", () => {
+  it("builds tree from flat list of files", () => {
+    const files: MarkdownFile[] = [
+      { slug: "alpha", filePath: "/alpha.md", frontmatter: { title: "Alpha" }, raw: "" },
+      { slug: "beta", filePath: "/beta.md", frontmatter: { title: "Beta" }, raw: "" },
+    ]
+
+    const tree = buildFileTree(files)
+    expect(tree).toHaveLength(2)
+    expect(tree[0].name).toBe("Alpha")
+    expect(tree[0].type).toBe("file")
+    expect(tree[0].path).toBe("alpha")
+    expect(tree[1].name).toBe("Beta")
+  })
+
+  it("creates folder nodes for nested files", () => {
+    const files: MarkdownFile[] = [
+      { slug: "notes/page1", filePath: "/notes/page1.md", frontmatter: { title: "Page 1" }, raw: "" },
+      { slug: "notes/page2", filePath: "/notes/page2.md", frontmatter: { title: "Page 2" }, raw: "" },
+    ]
+
+    const tree = buildFileTree(files)
+    expect(tree).toHaveLength(1)
+    expect(tree[0].type).toBe("folder")
+    expect(tree[0].name).toBe("notes")
+    expect(tree[0].children).toHaveLength(2)
+    expect(tree[0].children![0].name).toBe("Page 1")
+    expect(tree[0].children![1].name).toBe("Page 2")
+  })
+
+  it("uses frontmatter.title for file display name", () => {
+    const files: MarkdownFile[] = [
+      { slug: "my-file", filePath: "/my-file.md", frontmatter: { title: "Custom Title" }, raw: "" },
+    ]
+
+    const tree = buildFileTree(files)
+    expect(tree[0].name).toBe("Custom Title")
+  })
+
+  it("falls back to filename when no title", () => {
+    const files: MarkdownFile[] = [
+      { slug: "my-file", filePath: "/my-file.md", frontmatter: {}, raw: "" },
+    ]
+
+    const tree = buildFileTree(files)
+    expect(tree[0].name).toBe("my-file")
+  })
+
+  it("handles deeply nested structures", () => {
+    const files: MarkdownFile[] = [
+      { slug: "a/b/c", filePath: "/a/b/c.md", frontmatter: { title: "Deep" }, raw: "" },
+    ]
+
+    const tree = buildFileTree(files)
+    expect(tree[0].type).toBe("folder")
+    expect(tree[0].name).toBe("a")
+    expect(tree[0].children![0].type).toBe("folder")
+    expect(tree[0].children![0].name).toBe("b")
+    expect(tree[0].children![0].children![0].type).toBe("file")
+    expect(tree[0].children![0].children![0].name).toBe("Deep")
+  })
+
+  it("returns empty array for empty input", () => {
+    const tree = buildFileTree([])
+    expect(tree).toEqual([])
+  })
+})

package/src/__tests__/markdown.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect } from "vitest"
+import { renderMarkdown } from "../markdown"
+
+describe("renderMarkdown", () => {
+  it("returns empty result for empty string", async () => {
+    const result = await renderMarkdown("")
+    expect(result.html).toBe("")
+    expect(result.toc).toEqual([])
+    expect(result.tags).toEqual([])
+    expect(result.links).toEqual([])
+  })
+
+  it("extracts heading into toc", async () => {
+    const result = await renderMarkdown("# Hello World")
+    expect(result.toc).toHaveLength(1)
+    expect(result.toc[0]).toMatchObject({
+      depth: 1,
+      text: "Hello World",
+    })
+    expect(result.toc[0].id).toBeTruthy()
+  })
+
+  it("builds nested toc tree", async () => {
+    const md = "# Top\n## Sub\n### Deep"
+    const result = await renderMarkdown(md)
+    expect(result.toc).toHaveLength(1)
+    expect(result.toc[0].text).toBe("Top")
+    expect(result.toc[0].children).toHaveLength(1)
+    expect(result.toc[0].children[0].text).toBe("Sub")
+    expect(result.toc[0].children[0].children).toHaveLength(1)
+    expect(result.toc[0].children[0].children[0].text).toBe("Deep")
+  })
+
+  it("parses frontmatter", async () => {
+    const md = `---
+title: My Page
+date: 2024-01-01
+---
+
+Some content`
+    const result = await renderMarkdown(md)
+    expect(result.frontmatter.title).toBe("My Page")
+    // gray-matter parses YAML dates as Date objects
+    const date = result.frontmatter.date
+    const dateStr = date instanceof Date ? date.toISOString().split("T")[0] : date
+    expect(dateStr).toBe("2024-01-01")
+  })
+
+  it("extracts wikilinks into links array", async () => {
+    const result = await renderMarkdown("Check [[Some Page]] for details")
+    expect(result.links).toContain("Some Page")
+  })
+
+  it("extracts wikilink with alias", async () => {
+    const result = await renderMarkdown("See [[Target|display text]]")
+    expect(result.links).toContain("Target")
+    expect(result.html).toContain("display text")
+  })
+
+  it("extracts inline tags", async () => {
+    const result = await renderMarkdown("This has #mytag in it")
+    expect(result.tags).toContain("mytag")
+  })
+
+  it("merges frontmatter tags with inline tags and deduplicates", async () => {
+    const md = `---
+tags:
+  - alpha
+  - beta
+---
+
+Content with #beta and #gamma`
+    const result = await renderMarkdown(md)
+    expect(result.tags).toContain("alpha")
+    expect(result.tags).toContain("beta")
+    expect(result.tags).toContain("gamma")
+    // beta should appear only once
+    const betaCount = result.tags.filter((t) => t === "beta").length
+    expect(betaCount).toBe(1)
+  })
+
+  it("renders callout with correct class", async () => {
+    const md = "> [!note]\n> Some note content"
+    const result = await renderMarkdown(md)
+    expect(result.html).toContain("callout")
+    expect(result.html).toContain("callout-note")
+  })
+
+  it("renders LaTeX with KaTeX", async () => {
+    const result = await renderMarkdown("Inline math: $x^2$")
+    expect(result.html).toContain("katex")
+  })
+
+  it("renders display math with KaTeX", async () => {
+    const result = await renderMarkdown("$$\nx^2 + y^2 = z^2\n$$")
+    expect(result.html).toContain("katex")
+  })
+
+  it("generates html for basic markdown", async () => {
+    const result = await renderMarkdown("Hello **world**")
+    expect(result.html).toContain("<strong>world</strong>")
+  })
+
+  it("does not include embed links in outgoing links", async () => {
+    const result = await renderMarkdown("![[image.png]]")
+    expect(result.links).not.toContain("image.png")
+  })
+
+  it("adds slug ids to headings via rehype-slug", async () => {
+    const result = await renderMarkdown("## My Section")
+    expect(result.html).toContain('id="my-section"')
+  })
+})

package/src/__tests__/search.test.ts

@@ -0,0 +1,167 @@
+import { describe, it, expect } from "vitest"
+import { buildSearchIndex } from "../search"
+import type { MarkdownFile } from "../fs"
+
+function makeFile(overrides: Partial<MarkdownFile> & { slug: string }): MarkdownFile {
+  return {
+    filePath: `/${overrides.slug}.md`,
+    frontmatter: {},
+    raw: "",
+    ...overrides,
+  }
+}
+
+describe("buildSearchIndex", () => {
+  it("returns SearchEntry[] with slug, title, content, tags", () => {
+    const files: MarkdownFile[] = [
+      makeFile({
+        slug: "hello",
+        frontmatter: { title: "Hello", tags: ["greeting"] },
+        raw: "---\ntitle: Hello\ntags:\n  - greeting\n---\nSome body text",
+      }),
+    ]
+
+    const index = buildSearchIndex(files)
+    expect(index).toHaveLength(1)
+    expect(index[0].slug).toBe("hello")
+    expect(index[0].title).toBe("Hello")
+    expect(index[0].content).toContain("Some body text")
+    expect(index[0].tags).toEqual(["greeting"])
+  })
+
+  it("excludes draft:true files", () => {
+    const files: MarkdownFile[] = [
+      makeFile({
+        slug: "published",
+        frontmatter: { title: "Published" },
+        raw: "Public content",
+      }),
+      makeFile({
+        slug: "draft",
+        frontmatter: { title: "Draft", draft: true },
+        raw: "---\ntitle: Draft\ndraft: true\n---\nDraft content",
+      }),
+    ]
+
+    const index = buildSearchIndex(files)
+    expect(index).toHaveLength(1)
+    expect(index[0].slug).toBe("published")
+  })
+
+  it("strips heading markers from content", () => {
+    const files: MarkdownFile[] = [
+      makeFile({
+        slug: "headings",
+        raw: "# Heading One\n## Heading Two\nBody",
+      }),
+    ]
+
+    const index = buildSearchIndex(files)
+    expect(index[0].content).not.toMatch(/^#/)
+    expect(index[0].content).toContain("Heading One")
+    expect(index[0].content).toContain("Body")
+  })
+
+  it("strips bold and italic markers", () => {
+    const files: MarkdownFile[] = [
+      makeFile({
+        slug: "emphasis",
+        raw: "Some **bold** and *italic* and __also__ text",
+      }),
+    ]
+
+    const index = buildSearchIndex(files)
+    expect(index[0].content).not.toContain("**")
+    expect(index[0].content).not.toContain("*")
+    expect(index[0].content).not.toContain("__")
+    expect(index[0].content).toContain("bold")
+    expect(index[0].content).toContain("italic")
+  })
+
+  it("strips inline code", () => {
+    const files: MarkdownFile[] = [
+      makeFile({
+        slug: "code",
+        raw: "Use `console.log` to debug",
+      }),
+    ]
+
+    const index = buildSearchIndex(files)
+    expect(index[0].content).not.toContain("`")
+  })
+
+  it("strips wikilinks keeping display text", () => {
+    const files: MarkdownFile[] = [
+      makeFile({
+        slug: "links",
+        raw: "See [[My Page]] and [[Other|display]]",
+      }),
+    ]
+
+    const index = buildSearchIndex(files)
+    // wikilink regex captures target (first group), not alias
+    // [[My Page]] → "My Page", [[Other|display]] → "Other"
+    expect(index[0].content).toContain("My Page")
+    expect(index[0].content).toContain("Other")
+    expect(index[0].content).not.toContain("[[")
+    expect(index[0].content).not.toContain("]]")
+  })
+
+  it("uses last slug segment as title fallback", () => {
+    const files: MarkdownFile[] = [
+      makeFile({
+        slug: "notes/deep/my-page",
+        frontmatter: {},
+        raw: "Content without title",
+      }),
+    ]
+
+    const index = buildSearchIndex(files)
+    expect(index[0].title).toBe("my-page")
+  })
+
+  it("includes frontmatter tags", () => {
+    const files: MarkdownFile[] = [
+      makeFile({
+        slug: "tagged",
+        frontmatter: { tags: ["alpha", "beta"] },
+        raw: "---\ntags:\n  - alpha\n  - beta\n---\nContent",
+      }),
+    ]
+
+    const index = buildSearchIndex(files)
+    expect(index[0].tags).toEqual(["alpha", "beta"])
+  })
+
+  it("includes description from frontmatter", () => {
+    const files: MarkdownFile[] = [
+      makeFile({
+        slug: "desc",
+        frontmatter: { title: "Desc", description: "A short summary" },
+        raw: "---\ntitle: Desc\ndescription: A short summary\n---\nBody",
+      }),
+    ]
+
+    const index = buildSearchIndex(files)
+    expect(index[0].description).toBe("A short summary")
+  })
+
+  it("returns empty array for empty input", () => {
+    const index = buildSearchIndex([])
+    expect(index).toEqual([])
+  })
+
+  it("strips code blocks from content", () => {
+    const files: MarkdownFile[] = [
+      makeFile({
+        slug: "codeblock",
+        raw: "Before\n```js\nconsole.log('hi')\n```\nAfter",
+      }),
+    ]
+
+    const index = buildSearchIndex(files)
+    expect(index[0].content).not.toContain("console.log")
+    expect(index[0].content).toContain("Before")
+    expect(index[0].content).toContain("After")
+  })
+})