dsh-plugin-wiki-tools 0.3.0 → 0.5.0

package/lib/lint.js

@@ -8,7 +8,14 @@
 
 import { mkdir, readFile, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
-import { collectMarkdown, META_FILENAMES, splitFrontmatter, today } from './vault.js'
+import {
+  buildAliasMap,
+  collectMarkdown,
+  isMachineryPage,
+  resolveLinkTarget,
+  splitFrontmatter,
+  today,
+} from './vault.js'
 
 /** Frontmatter fields every content page must carry. */
 const REQUIRED_FIELDS = ['type', 'status', 'created', 'updated', 'tags']
@@ -53,10 +60,9 @@ export async function lintVault(root) {
  * @param {Add} add - issue recorder.
  */
 function checkDuplicateFilenames(pages, add) {
-  const isMachinery = page => META_FILENAMES.has(page.name.toLowerCase()) || page.name.startsWith('_')
   const seen = new Map()
   for (const page of pages) {
-    if (isMachinery(page)) continue
+    if (isMachineryPage(page.name)) continue
     const key = page.name.toLowerCase()
     if (seen.has(key)) {
       add('duplicate-filename', 'error', page.name,
@@ -99,18 +105,29 @@ async function checkStaleIndexEntries(root, pages, add) {
  * @param {Add} add - issue recorder.
  * @returns {Map<string, string[]>} inbound links per page title.
  */
+/**
+ * Wikilinks targeting pages that do not exist. Targets resolve through page
+ * titles first, then frontmatter `aliases` (Obsidian's order); only an
+ * unresolved target is dead.
+ * @param {Pages} pages - collected pages.
+ * @param {Add} add - issue recorder.
+ * @returns {Map<string, string[]>} inbound links per resolved page title.
+ */
 function checkDeadLinks(pages, add) {
   const names = new Set(pages.map(page => page.name))
+  const aliases = buildAliasMap(pages)
   const inbound = new Map(pages.map(page => [page.name, []]))
   for (const page of pages) {
+    if (isMachineryPage(page.name)) continue
     for (const target of page.links) {
-      if (names.has(target)) {
-        inbound.get(target)?.push(page.name)
+      const resolved = resolveLinkTarget(target, names, aliases)
+      if (resolved !== undefined) {
+        inbound.get(resolved)?.push(page.name)
         continue
       }
       add('dead-link', 'error', page.name,
         `links to [[${target}]] which does not exist`,
-        'Create a stub page or remove the link')
+        'Create a stub page, add the target to a page\u2019s aliases, or remove the link')
     }
   }
   return inbound
@@ -126,7 +143,7 @@ function checkDeadLinks(pages, add) {
 function checkOrphans(pages, inbound, indexed, add) {
   for (const page of pages) {
     const base = page.name.toLowerCase()
-    if (META_FILENAMES.has(base) || page.name.startsWith('_')) continue
+    if (isMachineryPage(page.name)) continue
     const links = inbound.get(page.name) ?? []
     const isIndexed = indexed.has(page.name)
     if (links.length === 0 && !isIndexed) {
@@ -145,7 +162,7 @@ function checkOrphans(pages, inbound, indexed, add) {
 function checkFrontmatterGaps(pages, add) {
   for (const page of pages) {
     const base = page.name.toLowerCase()
-    if (META_FILENAMES.has(base) || page.name.startsWith('_')) continue
+    if (isMachineryPage(page.name)) continue
     const missing = REQUIRED_FIELDS.filter(field => page.fields?.[field] === undefined)
     if (missing.length > 0) {
       add('frontmatter-gap', 'warn', page.name,
@@ -162,12 +179,25 @@ function checkFrontmatterGaps(pages, add) {
  */
 function checkEmptySections(pages, add) {
   for (const page of pages) {
-    if (META_FILENAMES.has(page.name.toLowerCase()) || page.name.startsWith('_')) continue
+    if (isMachineryPage(page.name)) continue
+    // Fence-aware scan: lines inside code fences are content (a section whose
+    // body is only code is not empty) and heading-like comment lines inside
+    // fences never open sections.
     const lines = [...page.content.split('\n'), '# __eof__ sentinel']
     let heading
     let headingLevel = 0
     let hasContent = false
+    let inFence = false
     for (const line of lines) {
+      if (line.startsWith('```')) {
+        inFence = !inFence
+        hasContent = true
+        continue
+      }
+      if (inFence) {
+        hasContent = true
+        continue
+      }
       const match = /^(#{1,6}) (.+)$/.exec(line)
       if (match !== null) {
         const nextLevel = match[1].length

package/lib/search.js

@@ -8,7 +8,7 @@
 
 import { readFile } from 'node:fs/promises'
 import { join } from 'node:path'
-import { collectMarkdown, META_FILENAMES } from './vault.js'
+import { buildAliasMap, collectMarkdown, isMachineryPage, resolveLinkTarget } from './vault.js'
 
 /**
  * Answer the quick mode: the hot cache and master index verbatim. The caller
@@ -40,20 +40,26 @@ export async function searchVault(root, { query, limit = 10 }) {
   const pages = await collectMarkdown(join(root, 'wiki'))
   // The link graph covers every file, but results exclude vault machinery:
   // the index matches nearly every term by construction and is already the
-  // quick-mode payload.
-  const searchable = pages.filter(page =>
-    !META_FILENAMES.has(page.name.toLowerCase()) && !page.name.startsWith('_'))
+  // quick-mode payload, and dated lint reports quote past wikilinks as records,
+  // not graph edges — so they neither appear as hits nor count as inbound.
+  const searchable = pages.filter(page => !isMachineryPage(page.name))
+  const names = new Set(pages.map(page => page.name))
+  const aliases = buildAliasMap(pages)
   const inbound = new Map(pages.map(page => [page.name, []]))
   for (const page of searchable) {
-    // One inbound record per source page, however many times it links.
+    // One inbound record per source page, however many times it links; alias
+    // targets resolve to their owning page.
     for (const target of new Set(page.links)) {
-      inbound.get(target)?.push(page.name)
+      const resolved = resolveLinkTarget(target, names, aliases)
+      if (resolved !== undefined) inbound.get(resolved)?.push(page.name)
     }
   }
   const results = []
   let totalMatches = 0
   for (const page of searchable) {
-    const titleHits = countOccurrences(page.name.toLowerCase(), needle) * 5
+    const aliasText = (page.aliases ?? []).join(' ').toLowerCase()
+    const titleHits = (countOccurrences(page.name.toLowerCase(), needle)
+      + (aliasText.includes(needle) ? 1 : 0)) * 5
     const tags = Array.isArray(page.fields?.tags) ? page.fields.tags.join(' ').toLowerCase() : ''
     const tagHits = tags.includes(needle) ? 4 : 0
     const headings = page.content.split('\n').filter(line => line.startsWith('#')).join('\n').toLowerCase()

package/lib/vault.js

@@ -382,23 +382,86 @@ export async function collectMarkdown(directory) {
         fields,
         content,
         links: extractWikilinks(content),
+        aliases: frontmatterAliases(fields),
       })
     }
   }
+  pages.sort((left, right) => left.name.localeCompare(right.name))
   return pages
 }
 
+/**
+ * Read a page's declared `aliases` frontmatter field (Obsidian resolves these
+ * as link targets): a string or list of strings.
+ * @param {Record<string, unknown> | undefined} fields - parsed frontmatter.
+ * @returns {string[]} declared aliases, empty when absent or malformed.
+ */
+function frontmatterAliases(fields) {
+  const raw = fields?.aliases
+  if (typeof raw === 'string') return raw.trim().length > 0 ? [raw.trim()] : []
+  if (Array.isArray(raw)) return raw.filter(alias => typeof alias === 'string' && alias.trim().length > 0).map(alias => alias.trim())
+  return []
+}
+
+/**
+ * Build the alias resolution map every link consumer shares: alias → page
+ * title. Earlier pages win a duplicate alias, deterministically, because
+ * {@link collectMarkdown} sorts by name.
+ * @param {{ name: string, aliases?: string[] }[]} pages - collected pages.
+ * @returns {Map<string, string>} alias → owning page title.
+ */
+export function buildAliasMap(pages) {
+  const map = new Map()
+  for (const page of pages) {
+    for (const alias of page.aliases ?? []) {
+      if (!map.has(alias)) map.set(alias, page.name)
+    }
+  }
+  return map
+}
+
+/**
+ * Resolve one wikilink target to a page title: direct name hit first, then the
+ * alias map (Obsidian's resolution order).
+ * @param {string} target - the raw link target.
+ * @param {Set<string>} names - every page title.
+ * @param {Map<string, string>} aliases - alias → page title.
+ * @returns {string | undefined} the resolved page title, or undefined when dead.
+ */
+export function resolveLinkTarget(target, names, aliases) {
+  if (names.has(target)) return target
+  return aliases.get(target)
+}
+
 /**
  * Extract wikilink targets from markdown, dropping aliases and heading anchors.
+ * Fenced code blocks and inline code spans are not links: examples written as
+ * `` `[[Target]]` `` must not join the graph.
  * @param {string} content - markdown body.
  * @returns {string[]} link targets in order of appearance.
  */
 export function extractWikilinks(content) {
   const links = []
-  const withoutFences = content.replace(/```[\s\S]*?```/g, '')
-  for (const match of withoutFences.matchAll(/\[\[([^\]]+)\]\]/g)) {
+  const withoutCode = content
+    .replace(/```[\s\S]*?```/g, '')
+    .replace(/`[^`\n]*`/g, '')
+  for (const match of withoutCode.matchAll(/\[\[([^\]]+)\]\]/g)) {
     const target = match[1].split('|')[0].split('#')[0].trim()
     if (target.length > 0) links.push(target)
   }
   return links
 }
+
+/**
+ * Whether a page basename is vault machinery rather than content: the index,
+ * log, hot cache, overview, per-folder sub-indexes, and dated lint reports.
+ * Lint reports quote past issues verbatim, so their wikilinks are records, not
+ * graph edges.
+ * @param {string} name - page basename without extension.
+ * @returns {boolean} whether the page is machinery.
+ */
+export function isMachineryPage(name) {
+  return META_FILENAMES.has(name.toLowerCase())
+    || name.startsWith('_')
+    || /^lint-report-/.test(name)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-wiki-tools",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Native DeepSeek Harness tools for an Obsidian wiki vault: wiki_query, wiki_write, and wiki_lint implement the mechanical core (path routing, delta tracking, index/log bookkeeping, health checks) of the wiki skill suite.",
   "license": "MIT",
   "type": "module",