cli-jaw 2.0.3 → 2.0.5

package/public/manager/src/notes/NotesQuickSwitcher.tsx

@@ -0,0 +1,187 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+import type { NoteMetadata } from '../types';
+
+type NotesQuickSwitcherProps = {
+    open: boolean;
+    notes: NoteMetadata[];
+    selectedPath: string | null;
+    onSelect: (path: string) => void;
+    onClose: () => void;
+};
+
+export type QuickSwitcherResult = {
+    note: NoteMetadata;
+    score: number;
+    reason: 'title' | 'path' | 'alias';
+};
+
+const MAX_RESULTS = 50;
+
+function normalize(value: string): string {
+    return value.trim().toLowerCase();
+}
+
+function fuzzyScore(value: string, query: string): number | null {
+    const haystack = normalize(value);
+    const needle = normalize(query);
+    if (!needle) return 1;
+    if (haystack.startsWith(needle)) return 1000 - haystack.length;
+    const contains = haystack.indexOf(needle);
+    if (contains >= 0) return 700 - contains;
+
+    let lastIndex = -1;
+    let consecutive = 0;
+    let score = 0;
+    for (const char of needle) {
+        const index = haystack.indexOf(char, lastIndex + 1);
+        if (index < 0) return null;
+        consecutive = index === lastIndex + 1 ? consecutive + 1 : 0;
+        score += 4 + consecutive * 3 - Math.min(index, 40) * 0.1;
+        lastIndex = index;
+    }
+    return score;
+}
+
+function scoreNote(note: NoteMetadata, query: string): QuickSwitcherResult | null {
+    const candidates: Array<{ value: string; reason: QuickSwitcherResult['reason']; boost: number }> = [
+        { value: note.title, reason: 'title', boost: 120 },
+        { value: note.path, reason: 'path', boost: 40 },
+        ...note.aliases.map(alias => ({ value: alias, reason: 'alias' as const, boost: 80 })),
+    ];
+
+    let best: QuickSwitcherResult | null = null;
+    for (const candidate of candidates) {
+        const fieldScore = fuzzyScore(candidate.value, query);
+        if (fieldScore == null) continue;
+        const scored = fieldScore + candidate.boost;
+        if (!best || scored > best.score) {
+            best = { note, score: scored, reason: candidate.reason };
+        }
+    }
+    return best;
+}
+
+export function filterQuickSwitcherNotes(notes: NoteMetadata[], query: string, limit = MAX_RESULTS): QuickSwitcherResult[] {
+    const trimmed = query.trim();
+    const results = notes
+        .map(note => scoreNote(note, trimmed))
+        .filter((result): result is QuickSwitcherResult => Boolean(result))
+        .sort((a, b) => {
+            if (b.score !== a.score) return b.score - a.score;
+            return a.note.path.localeCompare(b.note.path);
+        });
+    return results.slice(0, limit);
+}
+
+export function NotesQuickSwitcher(props: NotesQuickSwitcherProps) {
+    const [query, setQuery] = useState('');
+    const [activeIndex, setActiveIndex] = useState(0);
+    const inputRef = useRef<HTMLInputElement | null>(null);
+    const listRef = useRef<HTMLDivElement | null>(null);
+
+    const results = useMemo(() => filterQuickSwitcherNotes(props.notes, query), [props.notes, query]);
+    const activeId = results[activeIndex] ? `notes-quick-switcher-option-${activeIndex}` : undefined;
+
+    useEffect(() => {
+        if (!props.open) return;
+        setQuery('');
+        setActiveIndex(0);
+        requestAnimationFrame(() => inputRef.current?.focus());
+    }, [props.open]);
+
+    useEffect(() => {
+        if (activeIndex >= results.length) setActiveIndex(Math.max(0, results.length - 1));
+    }, [activeIndex, results.length]);
+
+    useEffect(() => {
+        const active = activeId ? document.getElementById(activeId) : null;
+        active?.scrollIntoView({ block: 'nearest' });
+    }, [activeId]);
+
+    function selectActive(): void {
+        const result = results[activeIndex];
+        if (!result) return;
+        props.onSelect(result.note.path);
+    }
+
+    function handleInputKey(event: React.KeyboardEvent<HTMLInputElement>): void {
+        if (event.key === 'ArrowDown') {
+            event.preventDefault();
+            setActiveIndex(index => Math.min(results.length - 1, index + 1));
+        } else if (event.key === 'ArrowUp') {
+            event.preventDefault();
+            setActiveIndex(index => Math.max(0, index - 1));
+        } else if (event.key === 'Enter') {
+            event.preventDefault();
+            selectActive();
+        } else if (event.key === 'Escape') {
+            event.preventDefault();
+            props.onClose();
+        }
+    }
+
+    if (!props.open) return null;
+
+    return (
+        <div className="notes-quick-switcher-backdrop" role="presentation" onClick={props.onClose}>
+            <section
+                className="notes-quick-switcher"
+                role="dialog"
+                aria-modal="true"
+                aria-label="Quick switch note"
+                onClick={event => event.stopPropagation()}
+            >
+                <input
+                    ref={inputRef}
+                    className="notes-quick-switcher-input"
+                    type="search"
+                    placeholder="Go to note"
+                    value={query}
+                    onChange={event => { setQuery(event.currentTarget.value); setActiveIndex(0); }}
+                    onKeyDown={handleInputKey}
+                    aria-label="Quick switch note"
+                    aria-controls="notes-quick-switcher-results"
+                    aria-activedescendant={activeId}
+                />
+                <div
+                    id="notes-quick-switcher-results"
+                    className="notes-quick-switcher-list"
+                    role="listbox"
+                    aria-label="Matching notes"
+                    ref={listRef}
+                >
+                    {results.map((result, index) => {
+                        const active = index === activeIndex;
+                        const current = result.note.path === props.selectedPath;
+                        return (
+                            <button
+                                id={`notes-quick-switcher-option-${index}`}
+                                key={result.note.path}
+                                type="button"
+                                role="option"
+                                aria-selected={active}
+                                className={`notes-quick-switcher-item${active ? ' is-active' : ''}${current ? ' is-current' : ''}`}
+                                onMouseEnter={() => setActiveIndex(index)}
+                                onClick={() => props.onSelect(result.note.path)}
+                            >
+                                <span className="notes-quick-switcher-title">{result.note.title || result.note.path}</span>
+                                <span className="notes-quick-switcher-path">{result.note.path}</span>
+                                <span className="notes-quick-switcher-alias">
+                                    {current ? 'Current note' : result.reason === 'alias' ? 'Alias match' : result.reason === 'path' ? 'Path match' : 'Title match'}
+                                </span>
+                            </button>
+                        );
+                    })}
+                    {results.length === 0 && (
+                        <p className="notes-quick-switcher-empty">No matching notes.</p>
+                    )}
+                </div>
+                <footer className="notes-quick-switcher-footer">
+                    <span><kbd>Up/Down</kbd> move</span>
+                    <span><kbd>Enter</kbd> open</span>
+                    <span><kbd>Esc</kbd> close</span>
+                </footer>
+            </section>
+        </div>
+    );
+}

package/public/manager/src/notes/NotesSearchSidebar.tsx

@@ -0,0 +1,118 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { searchNotes } from './notes-api';
+import type { NoteSearchResult } from './notes-types';
+import type { NotesSidebarMode } from './NotesSidebar';
+
+type NotesSearchSidebarProps = {
+    focusToken: number;
+    onSelect: (path: string) => void;
+    onModeChange: (mode: NotesSidebarMode) => void;
+};
+
+const MIN_QUERY_LENGTH = 2;
+const SEARCH_DEBOUNCE_MS = 275;
+const SEARCH_LIMIT = 20;
+
+function isAbortError(error: unknown): boolean {
+    return error instanceof DOMException && error.name === 'AbortError';
+}
+
+export function NotesSearchSidebar(props: NotesSearchSidebarProps) {
+    const [query, setQuery] = useState('');
+    const [results, setResults] = useState<NoteSearchResult[]>([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+    const inputRef = useRef<HTMLInputElement>(null);
+    const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+    const abortRef = useRef<AbortController | null>(null);
+
+    const cancelSearch = useCallback((): void => {
+        if (timerRef.current) clearTimeout(timerRef.current);
+        timerRef.current = null;
+        abortRef.current?.abort();
+        abortRef.current = null;
+    }, []);
+
+    useEffect(() => {
+        inputRef.current?.focus();
+    }, [props.focusToken]);
+
+    useEffect(() => {
+        return () => cancelSearch();
+    }, [cancelSearch]);
+
+    const runSearch = useCallback((value: string): void => {
+        const trimmed = value.trim();
+        cancelSearch();
+        setError(null);
+        if (trimmed.length < MIN_QUERY_LENGTH) {
+            setResults([]);
+            setLoading(false);
+            return;
+        }
+        const controller = new AbortController();
+        abortRef.current = controller;
+        setLoading(true);
+        void searchNotes(trimmed, { limit: SEARCH_LIMIT, signal: controller.signal })
+            .then(nextResults => {
+                if (!controller.signal.aborted) setResults(nextResults);
+            })
+            .catch(err => {
+                if (controller.signal.aborted || isAbortError(err)) return;
+                setResults([]);
+                setError((err as Error).message || 'Search failed');
+            })
+            .finally(() => {
+                if (!controller.signal.aborted) setLoading(false);
+            });
+    }, [cancelSearch]);
+
+    function handleQueryChange(value: string): void {
+        setQuery(value);
+        if (timerRef.current) clearTimeout(timerRef.current);
+        timerRef.current = setTimeout(() => runSearch(value), SEARCH_DEBOUNCE_MS);
+    }
+
+    function handleKeyDown(event: React.KeyboardEvent): void {
+        if (event.key !== 'Escape') return;
+        event.preventDefault();
+        props.onModeChange('files');
+    }
+
+    return (
+        <section className="notes-search-sidebar" aria-label="Search notes" onKeyDown={handleKeyDown}>
+            <div className="notes-search-sidebar-header">
+                <input
+                    ref={inputRef}
+                    className="notes-search-input"
+                    type="search"
+                    placeholder="Search notes"
+                    value={query}
+                    onChange={event => handleQueryChange(event.currentTarget.value)}
+                    aria-label="Search notes"
+                />
+            </div>
+            <div className="notes-search-sidebar-results" aria-live="polite">
+                {loading && <div className="notes-search-loading">Searching...</div>}
+                {error && <div className="notes-search-error">{error}</div>}
+                {!error && results.map(result => (
+                    <button
+                        key={`${result.kind}:${result.path}:${result.line}:${result.context}`}
+                        type="button"
+                        className="notes-search-result"
+                        onClick={() => props.onSelect(result.path)}
+                    >
+                        <span className="notes-search-result-path">{result.path}</span>
+                        <span className="notes-search-result-line">
+                            {result.kind === 'path' ? 'Path match' : `Line ${result.line}`}
+                        </span>
+                        <span className="notes-search-result-context">{result.context}</span>
+                    </button>
+                ))}
+                {!loading && !error && query.trim().length >= MIN_QUERY_LENGTH && results.length === 0 && (
+                    <div className="notes-search-empty">No results</div>
+                )}
+            </div>
+        </section>
+    );
+}

package/public/manager/src/notes/NotesSidebar.tsx

@@ -1,9 +1,12 @@
-import { useEffect, useState } from 'react';
+import { useEffect, useState, type CSSProperties } from 'react';
 import { createNoteFile, createNoteFolder, renameNotePath, trashNotePath } from './notes-api';
-import { NotesFileTree } from './NotesFileTree';
+import { NewFolderIcon, NewNoteIcon, NotesFileTree, RefreshIcon } from './NotesFileTree';
+import { NotesSearchSidebar } from './NotesSearchSidebar';
 import { publishInvalidation } from '../sync/invalidation-bus';
 import type { NotesTreeEntry } from './notes-types';
 
+export type NotesSidebarMode = 'files' | 'search';
+
 type NotesSidebarProps = {
     tree: NotesTreeEntry[];
     loading: boolean;
@@ -12,8 +15,15 @@ type NotesSidebarProps = {
     selectedPath: string | null;
     dirtyPath: string | null;
     treeWidth: number;
+    mode: NotesSidebarMode;
+    searchFocusToken: number;
+    tagFilter: string | null;
+    selectedHiddenByFilter: boolean;
+    onModeChange: (mode: NotesSidebarMode) => void;
+    onOpenSearch: () => void;
     onSelectedPathChange: (path: string | null) => void;
     onRefreshTree: (selectPath?: string | null) => Promise<void>;
+    onClearTagFilter: () => void;
 };
 
 function movePathToFolder(path: string, folderPath: string | null): string {
@@ -75,7 +85,17 @@ function batchTrashConfirmMessage(items: { path: string; kind: NotesTreeEntry['k
     return dirty ? `${label}\n\nThere are unsaved changes inside this selection.` : label;
 }
 
+function SearchIcon() {
+    return (
+        <svg viewBox="0 0 18 18" aria-hidden="true" className="notes-tree-action-icon">
+            <path d="M7.8 3.2a4.6 4.6 0 1 1 0 9.2 4.6 4.6 0 0 1 0-9.2Z" fill="none" stroke="currentColor" strokeWidth="1.5" />
+            <path d="m11.3 11.3 3.2 3.2" fill="none" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" />
+        </svg>
+    );
+}
+
 export function NotesSidebar(props: NotesSidebarProps) {
+    const style = { '--notes-tree-width': `${props.treeWidth}px` } as CSSProperties;
     const [error, setError] = useState<string | null>(null);
     const [status, setStatus] = useState<string | null>(null);
     const [selectedFolderPath, setSelectedFolderPath] = useState<string | null>(null);
@@ -121,7 +141,7 @@ export function NotesSidebar(props: NotesSidebarProps) {
         }
     }
 
-    async function moveNote(from: string, toFolder: string | null): Promise<void> {
+    async function movePath(from: string, toFolder: string | null): Promise<void> {
         const to = movePathToFolder(from, toFolder);
         if (from === to) return;
         try {
@@ -232,27 +252,71 @@ export function NotesSidebar(props: NotesSidebarProps) {
     }
 
     return (
-        <>
+        <aside className="notes-tree" style={style}>
             {(props.error || error) && <section className="state error-state">{props.error || error}</section>}
             {status && <section className="state notes-status-state">{status}</section>}
-            <NotesFileTree
-                entries={props.tree}
-                selectedPath={props.selectedPath}
-                selectedFolderPath={selectedFolderPath}
-                dirtyPath={props.dirtyPath}
-                loading={props.loading}
-                width={props.treeWidth}
-                notesRoot={props.notesRoot}
-                onSelectPath={props.onSelectedPathChange}
-                onSelectFolder={setSelectedFolderPath}
-                onMovePath={(from, toFolder) => void moveNote(from, toFolder)}
-                onRenamePath={(path, kind) => void renamePath(path, kind)}
-                onTrashPath={(path, kind) => void trashPath(path, kind)}
-                onTrashPaths={items => void trashPaths(items)}
-                onCreateNote={() => void createNote()}
-                onCreateFolder={() => void createFolder()}
-                onRefresh={() => void props.onRefreshTree()}
-            />
-        </>
+            <div className="notes-tree-header">
+                <strong>Notes</strong>
+                <div className="notes-tree-actions">
+                    <button
+                        type="button"
+                        className={props.mode === 'search' ? 'is-active' : ''}
+                        onClick={() => {
+                            if (props.mode === 'search') props.onModeChange('files');
+                            else props.onOpenSearch();
+                        }}
+                        title="Search notes"
+                        aria-label="Search notes"
+                        aria-pressed={props.mode === 'search'}
+                    >
+                        <SearchIcon />
+                    </button>
+                    <button type="button" onClick={() => void createNote()} title="New note" aria-label="New note"><NewNoteIcon /></button>
+                    <button type="button" onClick={() => void createFolder()} title="New folder" aria-label="New folder"><NewFolderIcon /></button>
+                    <button type="button" onClick={() => void props.onRefreshTree()} disabled={props.loading} title="Refresh notes" aria-label="Refresh notes"><RefreshIcon /></button>
+                </div>
+            </div>
+            {props.mode === 'files' ? (
+                <>
+                    {props.tagFilter && (
+                        <div className="notes-tag-filter-banner" role="status">
+                            <span className="notes-tag-filter-banner-meta">
+                                <span>Tag: #{props.tagFilter}</span>
+                                {props.selectedHiddenByFilter && (
+                                    <span className="notes-tag-filter-banner-hint">Selected note hidden by filter</span>
+                                )}
+                            </span>
+                            <button
+                                type="button"
+                                className="notes-tag-filter-clear"
+                                onClick={props.onClearTagFilter}
+                            >
+                                Clear
+                            </button>
+                        </div>
+                    )}
+                    <NotesFileTree
+                        entries={props.tree}
+                        selectedPath={props.selectedPath}
+                        selectedFolderPath={selectedFolderPath}
+                        dirtyPath={props.dirtyPath}
+                        loading={props.loading}
+                        notesRoot={props.notesRoot}
+                        onSelectPath={props.onSelectedPathChange}
+                        onSelectFolder={setSelectedFolderPath}
+                        onMovePath={(from, toFolder) => void movePath(from, toFolder)}
+                        onRenamePath={(path, kind) => void renamePath(path, kind)}
+                        onTrashPath={(path, kind) => void trashPath(path, kind)}
+                        onTrashPaths={items => void trashPaths(items)}
+                    />
+                </>
+            ) : (
+                <NotesSearchSidebar
+                    focusToken={props.searchFocusToken}
+                    onSelect={props.onSelectedPathChange}
+                    onModeChange={props.onModeChange}
+                />
+            )}
+        </aside>
     );
 }

package/public/manager/src/notes/NotesWorkspace.tsx

@@ -1,29 +1,36 @@
-import { useEffect, useRef } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import { MarkdownEditor } from './MarkdownEditor';
 import { MarkdownPreview } from './MarkdownPreview';
 import { NotesEmptyState } from './NotesEmptyState';
+import { NotesFrontmatterStrip } from './NotesFrontmatterStrip';
+import { NotesQuickSwitcher } from './NotesQuickSwitcher';
 import { NotesToolbar } from './NotesToolbar';
 import { renameNotePath } from './notes-api';
 import { useNoteDocument } from './useNoteDocument';
 import { publishInvalidation } from '../sync/invalidation-bus';
-import type { NotesAuthoringMode, NotesVaultIndexSnapshot, NotesViewMode } from './notes-types';
+import type { NotesAuthoringMode, NotesNoteMetadata, NotesVaultIndexSnapshot, NotesViewMode } from './notes-types';
 
 type NotesPrimaryMode = 'raw' | 'preview' | 'wysiwyg';
 
 type NotesWorkspaceProps = {
     active: boolean;
     selectedPath: string | null;
+    selectedNote: NotesNoteMetadata | null;
     vaultIndex: NotesVaultIndexSnapshot | null;
     viewMode: NotesViewMode;
     authoringMode: NotesAuthoringMode;
     wordWrap: boolean;
     treeWidth: number;
+    tagFilter: string | null;
+    onOpenSidebarSearch: () => void;
     onSelectedPathChange: (path: string | null) => void;
     onDirtyPathChange: (path: string | null) => void;
     onViewModeChange: (mode: NotesViewMode) => void;
     onAuthoringModeChange: (mode: NotesAuthoringMode) => void;
     onWordWrapChange: (value: boolean) => void;
     onTreeWidthChange: (value: number) => void;
+    onTagSelect: (tag: string | null) => void;
+    onWikiLinkNavigate: (path: string) => void;
 };
 
 const PRIMARY_MODE_CYCLE: NotesPrimaryMode[] = ['raw', 'preview', 'wysiwyg'];
@@ -43,6 +50,7 @@ function primaryModeFor(viewMode: NotesViewMode, authoringMode: NotesAuthoringMo
 export function NotesWorkspace(props: NotesWorkspaceProps) {
     const document = useNoteDocument();
     const renamingRef = useRef(false);
+    const [quickSwitcherOpen, setQuickSwitcherOpen] = useState(false);
 
     useEffect(() => {
         if (!props.selectedPath) return;
@@ -84,6 +92,30 @@ export function NotesWorkspace(props: NotesWorkspaceProps) {
         return () => window.removeEventListener('keydown', handleModeShortcut);
     }, [props.active, props.viewMode, props.authoringMode, props.onViewModeChange, props.onAuthoringModeChange]);
 
+    useEffect(() => {
+        if (!props.active) return;
+        function handleSearchShortcut(event: KeyboardEvent): void {
+            if (!(event.metaKey || event.ctrlKey) || !event.shiftKey || event.key.toLowerCase() !== 'f') return;
+            event.preventDefault();
+            props.onOpenSidebarSearch();
+        }
+
+        window.addEventListener('keydown', handleSearchShortcut);
+        return () => window.removeEventListener('keydown', handleSearchShortcut);
+    }, [props.active, props.onOpenSidebarSearch]);
+
+    useEffect(() => {
+        if (!props.active) return;
+        function handleQuickSwitcherShortcut(event: KeyboardEvent): void {
+            if (!(event.metaKey || event.ctrlKey) || event.key.toLowerCase() !== 'p') return;
+            event.preventDefault();
+            setQuickSwitcherOpen(open => !open);
+        }
+
+        window.addEventListener('keydown', handleQuickSwitcherShortcut);
+        return () => window.removeEventListener('keydown', handleQuickSwitcherShortcut);
+    }, [props.active]);
+
     async function handleTitleBlur(event: React.FocusEvent<HTMLInputElement>): Promise<void> {
         if (renamingRef.current || !props.selectedPath) return;
         const newTitle = event.currentTarget.value.trim().replace(INVALID_TITLE_CHARS, '');
@@ -114,6 +146,9 @@ export function NotesWorkspace(props: NotesWorkspaceProps) {
 
     const showEditor = props.viewMode === 'raw' || props.viewMode === 'split';
     const showPreview = props.viewMode === 'preview' || props.viewMode === 'split';
+    const selectedOutgoingLinks = (props.selectedPath && props.vaultIndex?.outgoingLinks?.[props.selectedPath]) || [];
+    const indexedNotes = props.vaultIndex?.notes || [];
+    const wysiwygOwnsFrontmatter = props.authoringMode === 'wysiwyg' && showEditor;
 
     return (
         <section className="notes-workspace" aria-label="Notes workspace">
@@ -175,14 +210,51 @@ export function NotesWorkspace(props: NotesWorkspaceProps) {
                                 spellCheck={false}
                                 aria-label="Note title"
                             />
+                            {!wysiwygOwnsFrontmatter && (
+                                <NotesFrontmatterStrip
+                                    note={props.selectedNote}
+                                    activeTag={props.tagFilter}
+                                    onTagClick={props.onTagSelect}
+                                />
+                            )}
                             {showEditor && <div className="notes-editor-pane">
-                                <MarkdownEditor key={props.selectedPath} active={props.active && showEditor} authoringMode={props.authoringMode} content={document.content} notePath={props.selectedPath} wordWrap={props.wordWrap} onChange={document.setContent} />
+                                <MarkdownEditor
+                                    key={props.selectedPath}
+                                    active={props.active && showEditor}
+                                    authoringMode={props.authoringMode}
+                                    content={document.content}
+                                    notePath={props.selectedPath}
+                                    outgoing={selectedOutgoingLinks}
+                                    notes={indexedNotes}
+                                    activeTag={props.tagFilter}
+                                    wordWrap={props.wordWrap}
+                                    onChange={document.setContent}
+                                    onTagSelect={props.onTagSelect}
+                                    onWikiLinkNavigate={props.onWikiLinkNavigate}
+                                />
                             </div>}
-                            {showPreview && <MarkdownPreview markdown={document.content} />}
+                            {showPreview && (
+                                <MarkdownPreview
+                                    markdown={document.content}
+                                    outgoing={selectedOutgoingLinks}
+                                    notes={indexedNotes}
+                                    onWikiLinkNavigate={props.onWikiLinkNavigate}
+                                />
+                            )}
                         </div>
                     )}
                 </div>
             </main>
+            <NotesQuickSwitcher
+                open={quickSwitcherOpen}
+                notes={props.vaultIndex?.notes || []}
+                selectedPath={props.selectedPath}
+                onClose={() => setQuickSwitcherOpen(false)}
+                onSelect={(path) => {
+                    props.onSelectedPathChange(path);
+                    setQuickSwitcherOpen(false);
+                }}
+            />
         </section>
     );
 }

package/public/manager/src/notes/frontmatter-preview.ts

@@ -0,0 +1,16 @@
+export type PreviewFrontmatterSplit = {
+    frontmatterRaw: string | null;
+    body: string;
+};
+
+const LEADING_FRONTMATTER_RE = /^---[ \t]*\r?\n[\s\S]*?\r?\n---[ \t]*(?:\r?\n|$)/;
+
+export function splitPreviewFrontmatter(markdown: string): PreviewFrontmatterSplit {
+    const match = LEADING_FRONTMATTER_RE.exec(markdown);
+    if (!match) return { frontmatterRaw: null, body: markdown };
+    const frontmatterRaw = match[0];
+    return {
+        frontmatterRaw,
+        body: markdown.slice(frontmatterRaw.length),
+    };
+}

package/public/manager/src/notes/notes-api.ts

@@ -3,6 +3,7 @@ export {
     fetchNotesIndex,
     fetchNotesCapabilities,
     fetchNotesTree,
+    searchNotes,
     fetchNoteFile,
     createNoteFile,
     saveNoteFile,