secondbrain-py 0.2.1__py3-none-any.whl

brain/quartz_overrides/quartz/components/Search.tsx

@@ -0,0 +1,161 @@
+// Brain Search component — Phase 3.2 of the Wiki UX Overhaul.
+//
+// This file is a TEMPLATE. It is installed at
+// `<vault>/.quartz/quartz/components/Search.tsx` by `brain vault
+// render --overlay`, OVERWRITING the stock Quartz `Search.tsx` so the
+// component barrel (`components/index.ts`) re-exports the brain
+// override instead of upstream. It does NOT compile or run from the
+// brain repo itself — esbuild-loader inside the cloned Quartz
+// workspace bundles `./scripts/search.inline` into a string that this
+// component publishes via `Search.afterDOMLoaded`. The string is then
+// injected at `</body>` time by Quartz's `renderPage.tsx`.
+//
+// Why this override exists: stock Quartz renders search results as
+// `<h3>title</h3><p>snippet</p>` and offers no source filter. The brain
+// corpus mixes ingested transcripts (krisp / slack / gmail) with
+// authored notes (manual / vault), so a search popover that doesn't
+// surface "where did this come from" makes results visually
+// indistinguishable. P3.2 adds:
+//
+//   * Source-icon prefix per result row — a one-glance visual key for
+//     gmail / krisp / slack / manual / vault.
+//   * Source filter chips above the input — toggle to constrain the
+//     visible results. State persists in `localStorage` under
+//     `brain.search.activeSources` so a user's preferred slice
+//     survives SPA navigation and full reloads.
+//   * Lazy preview pane — when a result is selected (hover / arrow),
+//     fetch `static/contentBodies/<slug>.json` (P3.1's split body file)
+//     and render the full content. P3.1 left only a 240-char snippet
+//     in `contentIndex.json`; without lazy fetching the preview pane
+//     would be permanently truncated.
+//   * Date column — short ISO date or "Nd ago" for the past week.
+//
+// The component layer (this file) only ships the markup + class hooks.
+// All dynamic behaviour — chip state, lazy fetching, fuzzy match — is
+// owned by the inline script at `./scripts/search.inline.ts`.
+//
+// brain: source-icon mapping. Pinned here at module scope so the same
+// glyph table renders both inline (`renderResultRow` constant
+// references it) and in the SSR'd chip rail (the script reads it at
+// boot via the embedded JSON below). Unknown sources fall back to the
+// vault glyph — better than rendering an empty span.
+//
+// Coordination point: if a future ingest source is added (e.g. brain
+// grows a `notion` extractor), append it ONCE in
+// `quartz_overrides/quartz/util/sourceIcons.ts` (the canonical
+// SOURCE_ICONS table). This component, the inline search script, and
+// the TagContent override all import from that one util — so the new
+// glyph cascades to all three surfaces. Also append it to
+// `_search.scss`'s chip palette (via the chip data attribute) AND to
+// `commandPalette.inline.ts`'s `kindIcon()` helper if Cmd-K is rebuilt
+// to share the same icon vocabulary.
+import { QuartzComponent, QuartzComponentConstructor, QuartzComponentProps } from "./types"
+// @ts-ignore — esbuild-loader rewrites this to a bundled string.
+import script from "./scripts/search.inline"
+import { classNames } from "../util/lang"
+import { i18n } from "../i18n"
+import { SOURCE_ICONS, SOURCE_CHIP_ORDER } from "../util/sourceIcons"
+
+export interface SearchOptions {
+  enablePreview: boolean
+}
+
+const defaultOptions: SearchOptions = {
+  enablePreview: true,
+}
+
+// brain (P3.6 fix-4): source-icon table consolidated. Previously this
+// file declared its own `SOURCE_ICONS` constant duplicated against
+// `util/sourceIcons.ts` and `search.inline.ts`. All three sites now
+// share the canonical util — adding a new source is a one-line change
+// in `util/sourceIcons.ts`. The chip rail still serializes the table
+// into `data-brain-source-icons` so the inline script reads it back at
+// boot via `readSourceIcons` (defense in depth: even if the import
+// chain breaks at runtime, the SSR'd attribute keeps the chip glyphs
+// rendering).
+
+// brain: ordered list of chip values rendered above the search input.
+// Order is deterministic and pinned (vs. derived from the index) so
+// the chip rail looks identical even when the loaded corpus is missing
+// one source. Matches the `chipVocabularies.source` order in
+// `graph.inline.ts` so the two filter rails read as siblings. Sourced
+// from the shared `SOURCE_CHIP_ORDER` so the order stays in lock-step
+// with the canonical util.
+const CHIP_VALUES: ReadonlyArray<keyof typeof SOURCE_ICONS> = SOURCE_CHIP_ORDER
+
+export default ((userOpts?: Partial<SearchOptions>) => {
+  const Search: QuartzComponent = ({ displayClass, cfg }: QuartzComponentProps) => {
+    const opts = { ...defaultOptions, ...userOpts }
+    const searchPlaceholder = i18n(cfg.locale).components.search.searchBarPlaceholder
+    // brain: serialize the icon table once into a data attribute so the
+    // inline script can rebuild the chip glyphs without a duplicate
+    // hard-coded copy. JSON.stringify keeps the table escapable through
+    // the HTML attribute boundary.
+    const iconsJson = JSON.stringify(SOURCE_ICONS)
+    return (
+      <div class={classNames(displayClass, "search")}>
+        <button class="search-button">
+          <svg role="img" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 19.9 19.7">
+            <title>Search</title>
+            <g class="search-path" fill="none">
+              <path stroke-linecap="square" d="M18.5 18.3l-5.4-5.4" />
+              <circle cx="8" cy="8" r="7" />
+            </g>
+          </svg>
+          <p>{i18n(cfg.locale).components.search.title}</p>
+        </button>
+        <div class="search-container">
+          <div class="search-space">
+            {/* brain: chip rail above the input. The script attaches
+                click handlers and reads the icon table from the
+                `data-brain-source-icons` attribute on the rail's root.
+                `data-active="true"` is reflected by the script when
+                a chip is in the active set; CSS keys hover/focus
+                styling off the same attribute. */}
+            <div
+              class="brain-search-chips"
+              role="group"
+              aria-label="Filter by source"
+              data-brain-source-icons={iconsJson}
+            >
+              <button
+                type="button"
+                class="brain-search-chip brain-search-chip-all"
+                data-brain-source="__all__"
+                data-active="true"
+              >
+                All
+              </button>
+              {CHIP_VALUES.map((value) => (
+                <button
+                  type="button"
+                  class="brain-search-chip"
+                  data-brain-source={value}
+                  data-active="true"
+                >
+                  <span class="brain-search-chip-icon" aria-hidden="true">
+                    {SOURCE_ICONS[value]}
+                  </span>
+                  <span class="brain-search-chip-label">{value}</span>
+                </button>
+              ))}
+            </div>
+            <input
+              autocomplete="off"
+              class="search-bar"
+              name="search"
+              type="text"
+              aria-label={searchPlaceholder}
+              placeholder={searchPlaceholder}
+            />
+            <div class="search-layout" data-preview={opts.enablePreview}></div>
+          </div>
+        </div>
+      </div>
+    )
+  }
+
+  Search.afterDOMLoaded = script
+
+  return Search
+}) satisfies QuartzComponentConstructor

brain/quartz_overrides/quartz/components/SummaryLede.tsx

@@ -0,0 +1,72 @@
+// Brain summary-lede component — wave Q2-SUMMARY-WIKI.
+//
+// This file is a TEMPLATE. It is installed at
+// `<vault>/.quartz/quartz/components/SummaryLede.tsx` by `brain vault
+// render --overlay`. It does NOT compile or run from the brain repo
+// itself; the imports below resolve against the dependencies Quartz
+// pulls into the cloned workspace via `npm install`, not against any
+// package brain ships.
+//
+// Tested against Quartz v4.5.x (April 2026). The component shape
+// mirrors stock Quartz components — see `Backlinks.tsx` (also a
+// brain-overlayed component) for the canonical pattern. If a future
+// Quartz version restructures `QuartzComponent` / `QuartzComponentProps`,
+// pull the latest reference component from
+// https://github.com/jackyzha0/quartz/blob/v4/quartz/components/
+// and re-apply the brain tweaks below.
+//
+// Strategy — render `fileData.frontmatter.summary` as an inline TL;DR
+// above the article body. The Q1-D ``OllamaEnricher`` writes
+// ``documents.summary``; the Q2 vault export pipeline plumbs that
+// value into ``summary:`` frontmatter on the mirror file. This
+// component reads that frontmatter key and renders an `<aside>` block
+// with a soft "AI summary" eyebrow.
+//
+// When the frontmatter doesn't carry a ``summary`` (vault-tier notes
+// the enricher hasn't touched, or short docs below the
+// ``BRAIN_ENRICH_MIN_TOKENS`` threshold), the component renders
+// `null` — no empty aside, no visual leak.
+//
+// Pin: this component is registered in `quartz.layout.ts` under
+// `defaultContentPageLayout.beforeBody`, immediately after
+// `Component.TagList()` and before `Component.Breadcrumbs()`. That
+// places the lede above the article body but below the title /
+// content meta strip, which is the natural place for a TL;DR.
+//
+// Responsibility (CLAUDE.md rule 8): this file owns the Preact
+// component wrapper. Visual rules live in
+// `../styles/brain/_summary_lede.scss`. No inline script — the lede
+// is a static SSR'd block with no interactive behavior.
+
+import { QuartzComponent, QuartzComponentConstructor, QuartzComponentProps } from "./types"
+import { classNames } from "../util/lang"
+
+const SummaryLede: QuartzComponent = ({ fileData, displayClass }: QuartzComponentProps) => {
+  // brain: defensive type-narrowing — Quartz's `fileData.frontmatter`
+  // is typed as `Record<string, unknown>` because authors can write
+  // arbitrary YAML. Only a string `summary` is renderable; a list,
+  // object, or null falls through to `null` (no aside).
+  const raw = fileData.frontmatter?.summary
+  if (typeof raw !== "string") {
+    return null
+  }
+  const summary = raw.trim()
+  if (summary.length === 0) {
+    return null
+  }
+
+  return (
+    <aside class={classNames(displayClass, "brain-summary-lede")} aria-label="AI summary">
+      <span class="brain-summary-lede-eyebrow" aria-hidden="true">
+        AI summary
+      </span>
+      <p class="brain-summary-lede-body">{summary}</p>
+    </aside>
+  )
+}
+
+// brain: no component-css here — visuals live in the global
+// `_summary_lede.scss`, which is `@use`-imported via `custom.scss`. That
+// ensures the styles ship with EVERY page in the build.
+
+export default (() => SummaryLede) satisfies QuartzComponentConstructor

brain/quartz_overrides/quartz/components/index.ts

@@ -0,0 +1,92 @@
+// Brain wiki — components barrel re-export with brain extensions wired in.
+//
+// This file is a TEMPLATE. It is installed at
+// `<vault>/.quartz/quartz/components/index.ts` by `brain vault render
+// --overlay`, OVERWRITING the stock Quartz barrel. The overlay is a
+// 1:1 file copy (`src/brain/vault/quartz_overlay.py`), so this is
+// the canonical seam for ensuring the brain-extension component
+// files in this directory get re-exported under the
+// `Component.*` namespace consumed by `quartz.layout.ts`.
+//
+// Tested against Quartz v4.5.x (April 2026). If a future Quartz
+// version adds a new stock component, append its export below; the
+// ones that already exist are sourced verbatim from
+// https://github.com/jackyzha0/quartz/blob/v4/quartz/components/index.ts
+// and the brain extensions are appended at the bottom in their own
+// block.
+//
+// brain: stock Quartz component imports + exports — keep in lock-step
+// with the upstream `index.ts` linked above. If you upgrade Quartz,
+// diff upstream against this block and apply additions.
+import Content from "./pages/Content"
+import TagContent from "./pages/TagContent"
+import FolderContent from "./pages/FolderContent"
+import NotFound from "./pages/404"
+import ArticleTitle from "./ArticleTitle"
+import Darkmode from "./Darkmode"
+import ReaderMode from "./ReaderMode"
+import Head from "./Head"
+import PageTitle from "./PageTitle"
+import ContentMeta from "./ContentMeta"
+import Spacer from "./Spacer"
+import TableOfContents from "./TableOfContents"
+import Explorer from "./Explorer"
+import TagList from "./TagList"
+import Graph from "./Graph"
+import Backlinks from "./Backlinks"
+import Search from "./Search"
+import Footer from "./Footer"
+import DesktopOnly from "./DesktopOnly"
+import MobileOnly from "./MobileOnly"
+import RecentNotes from "./RecentNotes"
+import Breadcrumbs from "./Breadcrumbs"
+import Comments from "./Comments"
+import Flex from "./Flex"
+import ConditionalRender from "./ConditionalRender"
+
+// brain-extension: brain-only components added by the overlay. Each
+// is documented in its own file's top-of-file comment.
+//   * CommandPalette — Lane C redesign — Cmd/Ctrl-P palette modal.
+//     Renders hidden markup once globally (registered in
+//     `quartz.layout.ts` `afterBody`); the inline script
+//     `scripts/commandPalette.inline.ts` owns the open/close + fuzzy
+//     search lifecycle.
+import CommandPalette from "./CommandPalette"
+import RelatedDocs from "./RelatedDocs"
+//   * SummaryLede — wave Q2-SUMMARY-WIKI — renders the auto-summary
+//     stored in `frontmatter.summary` (sourced from Q1-D
+//     `documents.summary`) as a TL;DR block above the article body.
+//     Pin: `defaultContentPageLayout.beforeBody` slot.
+import SummaryLede from "./SummaryLede"
+
+export {
+  ArticleTitle,
+  Content,
+  TagContent,
+  FolderContent,
+  Darkmode,
+  ReaderMode,
+  Head,
+  PageTitle,
+  ContentMeta,
+  Spacer,
+  TableOfContents,
+  Explorer,
+  TagList,
+  Graph,
+  Backlinks,
+  Search,
+  Footer,
+  DesktopOnly,
+  MobileOnly,
+  RecentNotes,
+  NotFound,
+  Breadcrumbs,
+  Comments,
+  Flex,
+  ConditionalRender,
+  // brain-extension exports
+  CommandPalette,
+  RelatedDocs,
+  SummaryLede,
+}

brain/quartz_overrides/quartz/components/pages/TagContent.tsx

@@ -0,0 +1,272 @@
+// Brain TagContent — Phase 3.3 of the Wiki UX Overhaul.
+//
+// This file is a TEMPLATE. It is installed at
+// `<vault>/.quartz/quartz/components/pages/TagContent.tsx` by `brain
+// vault render --overlay`, OVERWRITING the stock Quartz page renderer
+// for tag listing pages. It does NOT compile or run from the brain
+// repo itself; imports are resolved by the cloned Quartz workspace.
+//
+// Why this override exists: stock Quartz's tag pages render via
+// `<PageList>` which produces a flat list with date + title + tag
+// pills. The brain corpus mixes ingested transcripts (krisp / slack /
+// gmail) with authored notes (manual / vault), so a tag listing that
+// doesn't surface the source is visually indistinguishable. P3.3
+// adds:
+//
+//   * Source-icon prefix per row — same vocabulary as the search
+//     popover (krisp 🎙️ / slack 💬 / gmail 📧 / manual ✍️ / vault 🌱).
+//   * 1-line snippet around the first occurrence of the tag in the
+//     doc's auto-generated description (falls back to the leading
+//     200 chars when the tag word is not present in the description).
+//   * Explicit `tagged: #<tag1> #<tag2>` footer enumerating all the
+//     doc's tags — replaces the upstream tag-pill cluster with a
+//     single denser footer line.
+//
+// Upstream's index-mode (the `tags === "/"` overview page listing all
+// tags) is preserved verbatim — only the per-tag listing path is
+// overridden. The brain customisation is the rendering of each doc
+// row inside the `else` branch.
+//
+// Tested against Quartz v4.5.x (April 2026). If a future Quartz
+// version restructures the `TagContent` component (e.g. moves the
+// per-tag rendering into its own file, or changes the
+// `QuartzComponentProps` shape), pull the latest from
+// https://github.com/jackyzha0/quartz/blob/v4/quartz/components/pages/TagContent.tsx
+// and re-apply the brain delta marked with `// brain:` below.
+
+import { QuartzComponent, QuartzComponentConstructor, QuartzComponentProps } from "../types"
+import style from "../styles/listPage.scss"
+import { Date as QuartzDate, getDate } from "../Date"
+import { PageList, SortFn, byDateAndAlphabeticalFolderFirst } from "../PageList"
+import { FullSlug, getAllSegmentPrefixes, resolveRelative, simplifySlug } from "../../util/path"
+import { QuartzPluginData } from "../../plugins/vfile"
+import { Root } from "hast"
+import { htmlToJsx } from "../../util/jsx"
+import { i18n } from "../../i18n"
+import { ComponentChildren } from "preact"
+import { concatenateResources } from "../../util/resources"
+import { inferSource, sourceIconFor } from "../../util/sourceIcons"
+
+interface TagContentOptions {
+  sort?: SortFn
+  numPages: number
+  // brain-extension: chars on either side of the first tag-occurrence
+  // in the description when constructing the per-row snippet. Pinned
+  // here so a future tweak (e.g. expanding to 240 chars to match the
+  // P3.1 contentIndex snippet budget) is a single-line change.
+  snippetWindow: number
+}
+
+const defaultOptions: TagContentOptions = {
+  numPages: 10,
+  snippetWindow: 100,
+}
+
+// brain: trim a single line of whitespace-collapsed text from ``description``
+// centred on the first occurrence of ``tag``. When the tag word is not
+// found we return the leading ``2 * window`` chars so the row still
+// shows context. Whitespace is collapsed (multi-newline + tabs → single
+// space) so the row stays a clean one-liner regardless of how the
+// upstream description plugin built it.
+//
+// Match is case-insensitive on the tag's leaf segment (the part after
+// the last `/` in nested tags like `interview/take-home`) — that's the
+// word users actually expect to see highlighted in body text.
+export function computeTagSnippet(
+  description: string,
+  tag: string,
+  window: number,
+): string {
+  const collapsed = description.replace(/\s+/g, " ").trim()
+  if (collapsed.length === 0) return ""
+  const leaf = tag.includes("/") ? tag.slice(tag.lastIndexOf("/") + 1) : tag
+  const idx = collapsed.toLowerCase().indexOf(leaf.toLowerCase())
+  if (idx < 0) {
+    return collapsed.slice(0, window * 2)
+  }
+  const start = Math.max(0, idx - window)
+  const end = Math.min(collapsed.length, idx + leaf.length + window)
+  const prefix = start > 0 ? "…" : ""
+  const suffix = end < collapsed.length ? "…" : ""
+  return `${prefix}${collapsed.slice(start, end)}${suffix}`
+}
+
+export default ((opts?: Partial<TagContentOptions>) => {
+  const options: TagContentOptions = { ...defaultOptions, ...opts }
+
+  const TagContent: QuartzComponent = (props: QuartzComponentProps) => {
+    const { tree, fileData, allFiles, cfg } = props
+    const slug = fileData.slug
+
+    if (!(slug?.startsWith("tags/") || slug === "tags")) {
+      throw new Error(`Component "TagContent" tried to render a non-tag page: ${slug}`)
+    }
+
+    const tag = simplifySlug(slug.slice("tags/".length) as FullSlug)
+    const allPagesWithTag = (t: string) =>
+      allFiles.filter((file) =>
+        (file.frontmatter?.tags ?? []).flatMap(getAllSegmentPrefixes).includes(t),
+      )
+
+    const content = (
+      (tree as Root).children.length === 0
+        ? fileData.description
+        : htmlToJsx(fileData.filePath!, tree)
+    ) as ComponentChildren
+    const cssClasses: string[] = fileData.frontmatter?.cssclasses ?? []
+    const classes = cssClasses.join(" ")
+
+    if (tag === "/") {
+      // brain: index-mode (tags listing all tags) — preserved verbatim
+      // from upstream. The brain delta is only applied to per-tag
+      // pages where the row count is small enough to render the dense
+      // icon + snippet + footer markup without overwhelming the
+      // viewport. The aggregate index page lists every tag with a
+      // PageList preview underneath, where the upstream rendering is
+      // the right fit.
+      const tags = [
+        ...new Set(
+          allFiles.flatMap((data) => data.frontmatter?.tags ?? []).flatMap(getAllSegmentPrefixes),
+        ),
+      ].sort((a, b) => a.localeCompare(b))
+      const tagItemMap: Map<string, QuartzPluginData[]> = new Map()
+      for (const t of tags) {
+        tagItemMap.set(t, allPagesWithTag(t))
+      }
+      return (
+        <div class="popover-hint">
+          <article class={classes}>
+            <p>{content}</p>
+          </article>
+          <p>{i18n(cfg.locale).pages.tagContent.totalTags({ count: tags.length })}</p>
+          <div>
+            {tags.map((t) => {
+              const pages = tagItemMap.get(t)!
+              const listProps = {
+                ...props,
+                allFiles: pages,
+              }
+
+              const contentPage = allFiles.filter((file) => file.slug === `tags/${t}`).at(0)
+
+              const root = contentPage?.htmlAst
+              const tagContent =
+                !root || root?.children.length === 0
+                  ? contentPage?.description
+                  : htmlToJsx(contentPage.filePath!, root)
+
+              const tagListingPage = `/tags/${t}` as FullSlug
+              const href = resolveRelative(fileData.slug!, tagListingPage)
+
+              return (
+                <div>
+                  <h2>
+                    <a class="internal tag-link" href={href}>
+                      {t}
+                    </a>
+                  </h2>
+                  {tagContent && <p>{tagContent}</p>}
+                  <div class="page-listing">
+                    <p>
+                      {i18n(cfg.locale).pages.tagContent.itemsUnderTag({ count: pages.length })}
+                      {pages.length > options.numPages && (
+                        <>
+                          {" "}
+                          <span>
+                            {i18n(cfg.locale).pages.tagContent.showingFirst({
+                              count: options.numPages,
+                            })}
+                          </span>
+                        </>
+                      )}
+                    </p>
+                    <PageList limit={options.numPages} {...listProps} sort={options?.sort} />
+                  </div>
+                </div>
+              )
+            })}
+          </div>
+        </div>
+      )
+    }
+
+    // brain: per-tag mode — replace the upstream `<PageList>` with a
+    // brain-styled row list. Sort uses the same default Quartz uses
+    // (`byDateAndAlphabeticalFolderFirst`) so the relative ordering
+    // matches user expectations (newest-first, undated trailing).
+    const sorter = options.sort ?? byDateAndAlphabeticalFolderFirst(cfg)
+    const pages = allPagesWithTag(tag).sort(sorter)
+
+    return (
+      <div class="popover-hint">
+        <article class={classes}>{content}</article>
+        <div class="page-listing">
+          <p>{i18n(cfg.locale).pages.tagContent.itemsUnderTag({ count: pages.length })}</p>
+          <ul class="section-ul brain-tag-results">
+            {pages.map((page) => {
+              const title = page.frontmatter?.title ?? page.slug ?? ""
+              const tags = page.frontmatter?.tags ?? []
+              const fmSource =
+                typeof page.frontmatter?.source === "string"
+                  ? (page.frontmatter.source as string)
+                  : undefined
+              const source = inferSource(page.slug ?? "", fmSource)
+              const icon = sourceIconFor(source)
+              const description = page.description ?? ""
+              const snippet = computeTagSnippet(description, tag, options.snippetWindow)
+              const dateObj = getDate(cfg, page)
+              const href = resolveRelative(fileData.slug!, page.slug!)
+
+              return (
+                <li class="section-li brain-tag-row" data-brain-source={source}>
+                  <a class="internal brain-tag-row-link" href={href}>
+                    <span
+                      class="brain-tag-icon"
+                      aria-hidden="true"
+                      data-brain-source={source}
+                    >
+                      {icon}
+                    </span>
+                    <span class="brain-tag-title">{title}</span>
+                    {dateObj && (
+                      <span class="brain-tag-date">
+                        <QuartzDate date={dateObj} locale={cfg.locale} />
+                      </span>
+                    )}
+                    {snippet && <span class="brain-tag-snippet">{snippet}</span>}
+                  </a>
+                  {tags.length > 0 && (
+                    <p class="brain-tag-footer">
+                      <span class="brain-tag-footer-label">tagged:</span>{" "}
+                      {tags.map((rowTag, i) => (
+                        // brain (P3.6 fix-6): bare `<>` fragments inside
+                        // a `.map()` trip Preact's runtime warning
+                        // ("Each child in a list should have a unique
+                        // key prop"). Promote to a span with a stable
+                        // `key={rowTag}` so the warning goes away and
+                        // the reconciler can match nodes correctly when
+                        // the tags list mutates between renders.
+                        <span key={rowTag} class="brain-tag-footer-fragment">
+                          {i > 0 ? " " : ""}
+                          <a
+                            class="internal tag-link brain-tag-footer-link"
+                            href={resolveRelative(fileData.slug!, `tags/${rowTag}` as FullSlug)}
+                          >
+                            #{rowTag}
+                          </a>
+                        </span>
+                      ))}
+                    </p>
+                  )}
+                </li>
+              )
+            })}
+          </ul>
+        </div>
+      </div>
+    )
+  }
+
+  TagContent.css = concatenateResources(style, PageList.css)
+  return TagContent
+}) satisfies QuartzComponentConstructor