pi-obsidian-memory 0.0.1 → 0.1.1

package/src/domain/validation/describe.ts

@@ -0,0 +1,137 @@
+import type { TValidationError } from "typebox/error"
+
+import { ESCAPED_POINTER } from "./constants.ts"
+import type { ErrorMessageOverride } from "./types.ts"
+
+export function describeSchemaErrors(errors: readonly TValidationError[], label: string): string[] {
+  return describeSchemaErrorsWith(errors, label, noOverride)
+}
+
+export function describeSchemaErrorsWith(
+  errors: readonly TValidationError[],
+  label: string,
+  override: ErrorMessageOverride,
+): string[] {
+  return errors
+    .filter((error) => !isReportedUnknownProperty(error, errors))
+    .flatMap((error) => describeError(error, label, override))
+}
+
+function noOverride(): null {
+  return null
+}
+
+function isReportedUnknownProperty(error: TValidationError, errors: readonly TValidationError[]): boolean {
+  if (error.keyword !== "boolean") {
+    return false
+  }
+
+  return errors.some(
+    (other) =>
+      other.keyword === "additionalProperties" &&
+      error.schemaPath === `${other.schemaPath}/additionalProperties` &&
+      other.params.additionalProperties.some((field) =>
+        [field, escapePointer(field)].some((name) => error.instancePath === `${other.instancePath}/${name}`),
+      ),
+  )
+}
+
+function describeError(error: TValidationError, label: string, override: ErrorMessageOverride): string[] {
+  const path = readablePath(error.instancePath)
+
+  if (error.keyword === "additionalProperties") {
+    return error.params.additionalProperties.map((field) => `${joinField(path, field)}: not a known field`)
+  }
+
+  let message = keywordMessage(error)
+  const custom = override(error)
+  if (custom) {
+    message = custom
+  }
+
+  if (path.length === 0) {
+    return [`${label}: ${message}`]
+  }
+
+  return [`${path}: ${message}`]
+}
+
+function keywordMessage(error: TValidationError): string {
+  switch (error.keyword) {
+    case "type":
+      return typeMessage(error.params.type)
+    case "required":
+      return `must have required properties ${error.params.requiredProperties.join(", ")}`
+    case "enum":
+      return "must be equal to one of the allowed values"
+    case "const":
+      return "must be equal to constant"
+    case "pattern":
+      return `must match pattern "${String(error.params.pattern)}"`
+    case "format":
+      return `must match format "${error.params.format}"`
+    case "not":
+      return "must not be valid"
+    case "boolean":
+      return "is not allowed"
+    case "anyOf":
+      return "must match a schema in anyOf"
+    case "oneOf":
+      return "must match exactly one schema in oneOf"
+    default:
+      return limitMessage(error)
+  }
+}
+
+function limitMessage(error: TValidationError): string {
+  switch (error.keyword) {
+    case "minLength":
+      return `must not have fewer than ${error.params.limit} characters`
+    case "maxLength":
+      return `must not have more than ${error.params.limit} characters`
+    case "minItems":
+      return `must not have fewer than ${error.params.limit} items`
+    case "maxItems":
+      return `must not have more than ${error.params.limit} items`
+    case "minimum":
+    case "maximum":
+    case "exclusiveMinimum":
+    case "exclusiveMaximum":
+      return `must be ${error.params.comparison} ${error.params.limit}`
+    default:
+      return `is invalid (${error.keyword})`
+  }
+}
+
+function typeMessage(type: string | string[]): string {
+  if (typeof type === "string") {
+    return `must be ${type}`
+  }
+
+  return `must be either ${type.join(" or ")}`
+}
+
+function readablePath(instancePath: string): string {
+  const segments = instancePath.slice(1).split("/")
+  if (!ESCAPED_POINTER.test(instancePath)) {
+    return segments.join(".")
+  }
+
+  return segments.map(unescapePointer).join(".")
+}
+
+function unescapePointer(field: string): string {
+  return field.replaceAll("~1", "/").replaceAll("~0", "~")
+}
+
+function escapePointer(field: string): string {
+  return field.replaceAll("~", "~0").replaceAll("/", "~1")
+}
+
+function joinField(path: string, field: string): string {
+  if (path.length === 0) {
+    return field
+  }
+
+  return `${path}.${field}`
+}

package/src/domain/validation/index.ts

@@ -0,0 +1,3 @@
+export * from "./constants.ts"
+export * from "./describe.ts"
+export * from "./types.ts"

package/src/domain/validation/types.ts

@@ -0,0 +1,3 @@
+import type { TValidationError } from "typebox/error"
+
+export type ErrorMessageOverride = (error: TValidationError) => string | null

package/src/domain/vault-access/absolute-candidate.ts

@@ -0,0 +1,81 @@
+import { posix, win32 } from "node:path"
+import { fileURLToPath } from "node:url"
+
+import type { PathPlatform } from "#src/domain/path-platform"
+import {
+  DRIVE_OR_UNC_START,
+  LOCAL_ADMIN_SHARE,
+  NAMESPACE_PREFIX,
+  NAMESPACE_UNC_PREFIX,
+  TRAILING_NAMESPACE_SEPARATOR,
+  UNICODE_SPACES,
+  WINDOWS_SHELL_DRIVE_PREFIX,
+} from "./constants.ts"
+
+export function absoluteCandidate(raw: string, cwd: string, home: string, platform: PathPlatform): string {
+  if (platform === "win32") {
+    return windowsCandidate(raw, cwd, home)
+  }
+
+  return posix.resolve(cwd, posixExpandedPath(raw, home))
+}
+
+function windowsCandidate(raw: string, cwd: string, home: string): string {
+  const expanded = expandedPath(raw, home)
+  const resolved = win32.resolve(cwd, expanded)
+  const stripped = resolved.replace(NAMESPACE_UNC_PREFIX, "\\\\").replace(NAMESPACE_PREFIX, "")
+  if (!DRIVE_OR_UNC_START.test(stripped)) {
+    return resolved.replace(TRAILING_NAMESPACE_SEPARATOR, "$1")
+  }
+
+  return stripped.replace(LOCAL_ADMIN_SHARE, (_share: string, drive: string) => `${drive.toUpperCase()}:\\`)
+}
+
+function posixExpandedPath(raw: string, home: string): string {
+  const native = withoutAtPrefix(raw.replace(UNICODE_SPACES, " "))
+
+  if (native === "~") {
+    return home
+  }
+  if (native.startsWith("~/")) {
+    return posix.join(home, native.slice(2))
+  }
+  if (native.startsWith("file://")) {
+    return fileURLToPath(native, { windows: false })
+  }
+
+  return native
+}
+
+function expandedPath(raw: string, home: string): string {
+  const spaced = raw.replace(UNICODE_SPACES, " ")
+  const native = windowsShellPath(withoutAtPrefix(spaced))
+
+  if (native === "~") {
+    return home
+  }
+  if (native.startsWith("~/") || native.startsWith("~\\")) {
+    return win32.join(home, native.slice(2))
+  }
+  if (native.startsWith("file://")) {
+    return fileURLToPath(native, { windows: true })
+  }
+
+  return native
+}
+
+function withoutAtPrefix(path: string): string {
+  if (path.startsWith("@")) {
+    return path.slice(1)
+  }
+
+  return path
+}
+
+function windowsShellPath(path: string): string {
+  if (path.startsWith("//") || path.includes("\\")) {
+    return path
+  }
+
+  return path.replace(WINDOWS_SHELL_DRIVE_PREFIX, (_prefix: string, drive: string) => `${drive.toUpperCase()}:/`)
+}

package/src/domain/vault-access/argument-tokens.ts

@@ -0,0 +1,22 @@
+import { QUOTE_CHARACTERS, TOKEN_SEPARATOR } from "./constants.ts"
+
+export function argumentTokens(command: string): string[] {
+  const tokens: string[] = []
+  let current = ""
+  let quote = ""
+  for (const character of command) {
+    if (quote) {
+      if (character === quote) quote = ""
+      else current += character
+    } else if (QUOTE_CHARACTERS.includes(character)) {
+      quote = character
+    } else if (TOKEN_SEPARATOR.test(character)) {
+      if (current) tokens.push(current)
+      current = ""
+    } else {
+      current += character
+    }
+  }
+  if (current) tokens.push(current)
+  return tokens
+}

package/src/domain/vault-access/command-mentions-vault.ts

@@ -0,0 +1,115 @@
+import { isInside } from "#src/domain/config"
+import { type PathPlatform, pathModule } from "#src/domain/path-platform"
+import { argumentTokens } from "./argument-tokens.ts"
+import {
+  COMPARABLE_ADMIN_SHARE,
+  COMPARABLE_NAMESPACE,
+  COMPARABLE_NAMESPACE_UNC,
+  DRIVE_PATH_PREFIXES,
+  FILE_URL_PREFIX,
+  HOME_PREFIXES,
+  PARENT_FOLDER_START,
+  PATH_FOLLOWS,
+  PATH_TOKEN_END,
+  PATH_TOKEN_START,
+  VARIABLE_REFERENCE,
+  WINDOWS_DRIVE_START,
+  WINDOWS_FILE_URL_PREFIX,
+} from "./constants.ts"
+import type { VaultForms } from "./types.ts"
+
+export function commandMentionsVault(
+  command: string,
+  cwd: string,
+  home: string,
+  vaults: string[],
+  platform: PathPlatform,
+): string | null {
+  const text = comparableText(command, platform)
+  const tokens = argumentTokens(command).map((token) => comparableText(token, platform).replace(/(?<=.)\.+$/, ""))
+  for (const vault of vaults) {
+    if (isInside(cwd, vault, platform) || mentionsForms(text, tokens, vaultForms(vault, cwd, home, platform))) {
+      return vault
+    }
+  }
+
+  return null
+}
+
+function mentionsForms(text: string, tokens: string[], forms: VaultForms): boolean {
+  return (
+    forms.anywhere.some((form) => appearsIn(text, form, PATH_TOKEN_END)) ||
+    forms.relative.some((form) => tokens.includes(form) || appearsIn(text, form, PATH_FOLLOWS))
+  )
+}
+
+function vaultForms(vault: string, cwd: string, home: string, platform: PathPlatform): VaultForms {
+  const absolute = comparableText(vault, platform)
+  const shellDriveForms = DRIVE_PATH_PREFIXES.flatMap((prefix) => shellDriveForm(absolute, prefix))
+  const downFromHome = relativeTo(home, vault, platform).filter((path) => !PARENT_FOLDER_START.test(path))
+  const homeForms = downFromHome.flatMap((path) => HOME_PREFIXES.map((prefix) => `${prefix}${path}`))
+  const fromCwd = relativeTo(cwd, vault, platform)
+  const dotSlashForms = fromCwd.filter((path) => !PARENT_FOLDER_START.test(path)).map((path) => `./${path}`)
+
+  return { anywhere: [absolute, ...shellDriveForms, ...homeForms], relative: [...fromCwd, ...dotSlashForms] }
+}
+
+function shellDriveForm(absolute: string, prefix: string): string[] {
+  if (!WINDOWS_DRIVE_START.test(absolute)) {
+    return []
+  }
+
+  return [`${prefix}${absolute[0]}${absolute.slice(2)}`]
+}
+
+function relativeTo(base: string, vault: string, platform: PathPlatform): string[] {
+  const path = pathModule(platform)
+  const relative = comparableText(path.relative(base, vault), platform)
+  if (relative === "" || path.isAbsolute(relative)) {
+    return []
+  }
+
+  return [relative]
+}
+
+function appearsIn(text: string, form: string, end: RegExp): boolean {
+  let index = text.indexOf(form)
+  while (index !== -1) {
+    const before = text.slice(0, index)
+    const after = text.slice(index + form.length)
+    if (PATH_TOKEN_START.test(before) && end.test(after)) {
+      return true
+    }
+    index = text.indexOf(form, index + 1)
+  }
+
+  return false
+}
+
+function cased(text: string, platform: PathPlatform): string {
+  if (platform === "linux") return text.replace(VARIABLE_REFERENCE, (name: string) => name.toLowerCase())
+  return text.toLowerCase()
+}
+
+function separated(text: string, platform: PathPlatform): string {
+  if (platform === "win32") return text.replaceAll("\\", "/")
+  return text
+}
+
+function withoutFileUrl(text: string, platform: PathPlatform): string {
+  if (platform === "win32") {
+    return text.replace(WINDOWS_FILE_URL_PREFIX, "")
+  }
+
+  return text.replace(FILE_URL_PREFIX, "")
+}
+
+function comparableText(text: string, platform: PathPlatform): string {
+  return separated(cased(withoutFileUrl(text, platform), platform), platform)
+    .replace(/["'`]/g, "")
+    .replace(COMPARABLE_NAMESPACE_UNC, "//")
+    .replace(COMPARABLE_NAMESPACE, "")
+    .replace(COMPARABLE_ADMIN_SHARE, (_share: string, drive: string) => `${drive}:`)
+    .replace(/\/{2,}/g, "/")
+    .replace(/(?<=.)\/$/, "")
+}

package/src/domain/vault-access/constants.ts

@@ -0,0 +1,54 @@
+export const VAULT_ACCESS_REFUSAL =
+  "Vault files are reachable only through memory_search and memory_get, never with file tools or the shell."
+
+export const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g
+
+export const WINDOWS_SHELL_DRIVE_PREFIX = /^\/(?:mnt\/|cygdrive\/)?([a-z])(?:\/|$)/i
+
+export const NAMESPACE_UNC_PREFIX = /^\\\\[?.]\\UNC\\/i
+
+export const TRAILING_NAMESPACE_SEPARATOR = /^(\\\\[?.]\\.+)\\$/
+
+export const FILE_URL_PREFIX = /(?<=^|[\s=(,;|&<>])file:\/\//g
+
+export const WINDOWS_FILE_URL_PREFIX = /(?<=^|[\s=(,;|&<>])file:\/\/\/(?=[a-z]:)/gi
+
+export const NAMESPACE_PREFIX = /^\\\\[?.]\\/
+
+export const LOCAL_ADMIN_SHARE = /^\\\\(?:localhost|127\.0\.0\.1)\\([a-z])\$(?:\\|$)/i
+
+export const DRIVE_OR_UNC_START = /^(?:[a-z]:|\\\\)/i
+
+export const COMPARABLE_NAMESPACE_UNC = /(?<=^|[\s=(,;|&<>])\/\/[?.]\/unc\//g
+
+export const COMPARABLE_NAMESPACE = /(?<=^|[\s=(,;|&<>])\/\/[?.]\//g
+
+export const COMPARABLE_ADMIN_SHARE = /(?<=^|[\s=(,;|&<>])\/\/(?:localhost|127\.0\.0\.1)\/([a-z])\$(?=\/|$)/g
+
+export const PATH_TOKEN_START = /(?:^|[\s=(,;|&<>])$/
+
+export const PATH_TOKEN_END = /^(?:$|[\s/|;&)<>,]|\.(?:$|[\s/]))/
+
+export const PATH_FOLLOWS = /^\.?\//
+
+export const QUOTE_CHARACTERS = ['"', "'", "`"]
+
+export const TOKEN_SEPARATOR = /[\s=|;&()<>,]/
+
+export const WINDOWS_DRIVE_START = /^[a-z]:\//
+
+export const DRIVE_PATH_PREFIXES = ["/", "/mnt/", "/cygdrive/"]
+
+export const VARIABLE_REFERENCE = /\$(?:env:)?\{?\w+\}?|%\w+%/gi
+
+export const PARENT_FOLDER_START = /^\.\.(\/|$)/
+
+export const HOME_PREFIXES = [
+  "~/",
+  "$home/",
+  "\u0024{home}/",
+  "$env:home/",
+  "%userprofile%/",
+  "$env:userprofile/",
+  "%homedrive%%homepath%/",
+]

package/src/domain/vault-access/index.ts

@@ -0,0 +1,7 @@
+export * from "./absolute-candidate.ts"
+export * from "./argument-tokens.ts"
+export * from "./command-mentions-vault.ts"
+export * from "./constants.ts"
+export * from "./types.ts"
+export * from "./vault-access-refusal.ts"
+export * from "./vault-location.ts"

package/src/domain/vault-access/types.ts

@@ -0,0 +1,18 @@
+export type PathAccessKind = "file" | "tree" | "listing"
+
+export interface PathAccessRequest {
+  kind: PathAccessKind
+  path: string
+}
+
+export interface CommandAccessRequest {
+  kind: "command"
+  command: string
+}
+
+export type VaultAccessRequest = PathAccessRequest | CommandAccessRequest
+
+export interface VaultForms {
+  anywhere: string[]
+  relative: string[]
+}

package/src/domain/vault-access/vault-access-refusal.ts

@@ -0,0 +1,36 @@
+import type { PathPlatform } from "#src/domain/path-platform"
+import { absoluteCandidate } from "./absolute-candidate.ts"
+import { commandMentionsVault } from "./command-mentions-vault.ts"
+import type { PathAccessRequest, VaultAccessRequest } from "./types.ts"
+import { vaultBelow, vaultContaining } from "./vault-location.ts"
+
+export function vaultAccessRefusal(
+  request: VaultAccessRequest,
+  cwd: string,
+  home: string,
+  vaults: string[],
+  platform: PathPlatform,
+): string | null {
+  if (request.kind === "command") {
+    return commandMentionsVault(request.command, cwd, home, vaults, platform)
+  }
+
+  return pathVaultHit(request, absoluteCandidate(request.path, cwd, home, platform), vaults, platform)
+}
+
+function pathVaultHit(
+  request: PathAccessRequest,
+  path: string,
+  vaults: string[],
+  platform: PathPlatform,
+): string | null {
+  const containing = vaultContaining(path, vaults, platform)
+  if (containing) {
+    return containing
+  }
+  if (request.kind === "tree") {
+    return vaultBelow(path, vaults, platform)
+  }
+
+  return null
+}

package/src/domain/vault-access/vault-location.ts

@@ -0,0 +1,22 @@
+import { isInside } from "#src/domain/config"
+import type { PathPlatform } from "#src/domain/path-platform"
+
+export function vaultContaining(path: string, vaults: string[], platform: PathPlatform): string | null {
+  for (const vault of vaults) {
+    if (isInside(path, vault, platform)) {
+      return vault
+    }
+  }
+
+  return null
+}
+
+export function vaultBelow(path: string, vaults: string[], platform: PathPlatform): string | null {
+  for (const vault of vaults) {
+    if (isInside(vault, path, platform)) {
+      return vault
+    }
+  }
+
+  return null
+}

package/src/domain/vault-assets/index.ts

@@ -0,0 +1,2 @@
+export * from "./render.ts"
+export * from "./types.ts"

package/src/domain/vault-assets/render.ts

@@ -0,0 +1,51 @@
+import { stringify } from "yaml"
+
+import { type NoteType, NoteTypeSchema } from "#src/domain/note"
+import type { DashboardView, VaultAsset, VaultDashboard } from "./types.ts"
+
+export function renderVaultAssets(): VaultAsset[] {
+  return [...NoteTypeSchema.enum.map(renderHandTemplate), { path: "Memory.base", content: stringify(dashboard()) }]
+}
+
+function renderHandTemplate(type: NoteType): VaultAsset {
+  return {
+    path: `_templates/${type}.md`,
+    content: [
+      "---",
+      "id: REPLACE_WITH_NEW_ULID",
+      `type: ${type}`,
+      'created: "{{date:YYYY-MM-DD}}"',
+      'updated: "{{date:YYYY-MM-DD}}"',
+      "---",
+      "",
+      "{{title}}",
+      "",
+    ].join("\n"),
+  }
+}
+
+function dashboard(): VaultDashboard {
+  return {
+    filters: {
+      and: [
+        'file.ext.lower() == "md"',
+        'file.basename.lower() != "index"',
+        '!file.path.lower().startsWith("_templates/")',
+      ],
+    },
+    views: [
+      view("All notes", ['!file.path.lower().startsWith("archive/")']),
+      view("Don't forget", ['!file.path.lower().startsWith("archive/")', "note.dontForget == true"]),
+      view("Archive", ['file.path.lower().startsWith("archive/")']),
+    ],
+  }
+}
+
+function view(name: string, filters: string[]): DashboardView {
+  return {
+    type: "table",
+    name,
+    filters: { and: filters },
+    order: ["file.name", "file.folder", "note.type", "note.dontForget", "note.updated"],
+  }
+}

package/src/domain/vault-assets/types.ts

@@ -0,0 +1,36 @@
+import type { VaultCatalogFailure } from "#src/domain/vault-catalog"
+import type { Failed, Succeeded } from "#src/shared"
+
+export interface VaultAsset {
+  path: string
+  content: string
+}
+
+export interface DashboardFilters {
+  and: string[]
+}
+
+export interface DashboardView {
+  type: "table"
+  name: string
+  filters: DashboardFilters
+  order: string[]
+}
+
+export interface VaultDashboard {
+  filters: DashboardFilters
+  views: DashboardView[]
+}
+
+export interface VaultBootstrapProgress {
+  createdRoot: boolean
+  created: string[]
+  preserved: string[]
+  maintenanceProblems: string[]
+}
+
+export interface VaultBootstrapFailure extends Failed, VaultBootstrapProgress {
+  failure: VaultCatalogFailure
+}
+
+export type VaultBootstrapResult = Succeeded<VaultBootstrapProgress> | VaultBootstrapFailure

package/src/domain/vault-catalog/analyze.ts

@@ -0,0 +1,37 @@
+import { checkNoteText, parseNote, readFrontmatter } from "#src/domain/note"
+import type { AnalyzeVaultNoteRequest, ParsedVaultNote, VaultNoteAnalysis, VaultNoteProblems } from "./types.ts"
+
+export function analyzeVaultNote(request: AnalyzeVaultNoteRequest): VaultNoteAnalysis {
+  const parsed = parseNote(request.statement, request.text)
+  if (!parsed.succeeded) {
+    const text = textProblems(request, request.text)
+    return { status: "unclosed", searchable: false, needsFixing: true, ...text, frontmatterProblems: parsed.problems }
+  }
+
+  const result: ParsedVaultNote = {
+    status: "parsed",
+    parsed: parsed.output,
+    frontmatter: null,
+    searchable: false,
+    needsFixing: true,
+    ...textProblems(request, parsed.output.body),
+  }
+  const frontmatter = readFrontmatter(parsed.output.frontmatter)
+  if (!frontmatter.succeeded) return { ...result, frontmatterProblems: frontmatter.problems }
+
+  return {
+    ...result,
+    frontmatter: frontmatter.output,
+    searchable: !request.archived && !("archived" in frontmatter.output),
+    needsFixing: result.nameProblems.length + result.bodyProblems.length > 0,
+  }
+}
+
+function textProblems(request: AnalyzeVaultNoteRequest, body: string): VaultNoteProblems {
+  const problems = checkNoteText(request.statement, body, request.limits)
+  return {
+    frontmatterProblems: [],
+    nameProblems: problems.filter((problem) => problem.startsWith("statement:")),
+    bodyProblems: problems.filter((problem) => problem.startsWith("body:")),
+  }
+}

package/src/domain/vault-catalog/classify.ts

@@ -0,0 +1,37 @@
+import type { VaultEntryKind } from "./types.ts"
+
+export function isRootArchive(path: string): boolean {
+  return path.split("/")[0]?.toLowerCase() === "archive"
+}
+
+export function isRootTemplate(path: string): boolean {
+  return path.split("/")[0]?.toLowerCase() === "_templates"
+}
+
+export function isCatalogHidden(path: string): boolean {
+  return path.split("/").some((part) => part.startsWith("."))
+}
+
+export function catalogFileKind(path: string): Exclude<VaultEntryKind, "folder"> {
+  const lower = path.toLowerCase()
+  const name = lower.split("/").at(-1)
+  if (/\.md\.tmp-[^/]+$/i.test(path) || /^\.memory\.base\.tmp-[^/]+$/.test(lower)) return "temporary"
+  if (isRootTemplate(path)) return "template"
+  if (name === "index.md") return "index"
+  if (lower === "memory.base") return "dashboard"
+  if (lower.endsWith(".md")) return "note"
+  return "other"
+}
+
+export function isCatalogNotePath(path: string): boolean {
+  const parent = path.slice(0, path.lastIndexOf("/") + 1)
+  return !isCatalogHidden(parent) && catalogFileKind(path) === "note"
+}
+
+export function isSafeCatalogPath(path: string): boolean {
+  return path.length > 0 && path.split("/").every(isSafeCatalogPart)
+}
+
+function isSafeCatalogPart(part: string): boolean {
+  return part.length > 0 && part !== "." && part !== ".." && !/[\\:]/.test(part) && !part.includes("\u0000")
+}

package/src/domain/vault-catalog/dont-forget.ts

@@ -0,0 +1,6 @@
+import type { VaultNoteAnalysis } from "./types.ts"
+
+export function isLoadedDontForget(analysis: VaultNoteAnalysis): boolean {
+  if (analysis.status !== "parsed" || !analysis.frontmatter) return false
+  return analysis.searchable && "dontForget" in analysis.frontmatter
+}