@life-and-dev/mdsite 0.7.0 → 0.7.1

package/mdsite-nuxt/content.config.ts

@@ -3,6 +3,26 @@ import { loadMdsiteConfigSync } from './utils/mdsite-config.js'
 
 const { contentDir } = loadMdsiteConfigSync()
 
+/**
+ * Build/dependency directories that should never be crawled as content.
+ *
+ * @nuxt/content v3 does not exclude `node_modules` or hidden directories
+ * by default (it passes `dot: true` to all glob/match calls), so a
+ * content directory that happens to be the project root (i.e. `mdsite.yml`
+ * lives at the repo root and `paths.input` is unset) would otherwise
+ * walk into the renderer working dir (`.mdsite/`), its `node_modules`,
+ * and other build artifacts.
+ *
+ * The rule mirrors `isExcludedSourceDir` in `scripts/generate-indices.ts`
+ * and `scripts/sync-content.ts`: any hidden directory (name starts with
+ * `.`) plus `node_modules` and `dist`. Keep the three lists in sync.
+ */
+const excludedSourcePatterns: readonly string[] = [
+  '**/node_modules/**',
+  '**/dist/**',
+  '**/.*/**'
+]
+
 export default defineContentConfig({
   collections: {
     content: defineCollection({
@@ -10,7 +30,7 @@ export default defineContentConfig({
       source: {
         cwd: contentDir,
         include: '**/*.md',
-        exclude: ['**/*.draft.md'],
+        exclude: [...excludedSourcePatterns, '**/*.draft.md'],
         prefix: '/'
       }
     })

package/mdsite-nuxt/scripts/generate-indices.test.ts

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
 
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { generateNavigationJson, generateSearchIndexJson, generateFooterJson } from './generate-indices.js'
 
@@ -402,4 +402,153 @@ describe('generated content indices', () => {
       expect(paths).not.toContain('/contacts')
     })
   })
+
+  describe('build/dependency directory exclusion', () => {
+    async function readSearchIndex() {
+      return JSON.parse(await fs.readFile(path.join(publicDir, '_search-index.json'), 'utf8'))
+    }
+
+    async function readNavigation() {
+      return JSON.parse(await fs.readFile(path.join(publicDir, '_navigation.json'), 'utf8'))
+    }
+
+    /**
+     * Build a fake content tree that mimics a project root used as the
+     * content directory: real user pages alongside build artifacts, hidden
+     * editor dirs, and a top-level `node_modules`/`dist`. Returns the set
+     * of "expected to be indexed" markdown paths.
+     */
+    async function plantMixedTree() {
+      // User-authored content at the content root
+      await fs.writeFile(path.join(contentDir, 'index.md'), '# Home\n\nWelcome home.', 'utf8')
+      await fs.writeFile(path.join(contentDir, 'guide.md'), '# Guide\n\nUseful guide.', 'utf8')
+      await fs.mkdir(path.join(contentDir, 'features'), { recursive: true })
+      await fs.writeFile(path.join(contentDir, 'features', 'theme.md'), '# Theme\n\nContent.', 'utf8')
+
+      // Renderer working dir with nested node_modules containing a README
+      // — mimics the layout the CLI materializes on first run.
+      await fs.mkdir(path.join(contentDir, '.mdsite', 'node_modules', 'some-pkg'), { recursive: true })
+      await fs.writeFile(
+        path.join(contentDir, '.mdsite', 'node_modules', 'some-pkg', 'README.md'),
+        '# some-pkg\n\nThis is a dependency README and should be ignored.'
+      )
+
+      // A top-level node_modules dir (e.g. when the content root IS the
+      // project root) should also be skipped.
+      await fs.mkdir(path.join(contentDir, 'node_modules', 'transitive'), { recursive: true })
+      await fs.writeFile(
+        path.join(contentDir, 'node_modules', 'transitive', 'README.md'),
+        '# transitive\n\nShould also be ignored.'
+      )
+
+      // A `dist` directory (top-level build output) should also be skipped.
+      await fs.mkdir(path.join(contentDir, 'dist', 'legacy'), { recursive: true })
+      await fs.writeFile(
+        path.join(contentDir, 'dist', 'legacy', 'stale.md'),
+        '# Stale\n\nShould be ignored.'
+      )
+
+      // Any hidden directory at any depth should be skipped — editor state,
+      // tooling caches, etc. `.vscode`, `.idea`, `.history`, `.cache` are
+      // all common offenders when the content root is the project root.
+      for (const hidden of ['.vscode', '.idea', '.history', '.cache']) {
+        await fs.mkdir(path.join(contentDir, hidden, 'notes'), { recursive: true })
+        await fs.writeFile(
+          path.join(contentDir, hidden, 'notes', 'scratch.md'),
+          `# ${hidden}\n\nShould be ignored.`
+        )
+      }
+
+      // Nuxt/Nitro/CMS output dirs that may sit next to the content.
+      for (const hidden of ['.nuxt', '.output', '.nitro', '.data', '.git']) {
+        await fs.mkdir(path.join(contentDir, hidden), { recursive: true })
+        await fs.writeFile(
+          path.join(contentDir, hidden, 'scratch.md'),
+          `# ${hidden}\n\nShould be ignored.`
+        )
+      }
+    }
+
+    it('does not index .md files under any hidden directory, node_modules, or dist', async () => {
+      await plantMixedTree()
+
+      // console.warn would log a "No H1 found" notice for any file the
+      // walker still visited — silence it so the test output stays clean.
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+      try {
+        await generateSearchIndexJson()
+      } finally {
+        warnSpy.mockRestore()
+      }
+
+      const searchIndex = await readSearchIndex()
+      const paths = searchIndex.map((entry: { path: string }) => entry.path)
+      // User-authored pages are still indexed
+      expect(paths).toContain('/')
+      expect(paths).toContain('/guide')
+      expect(paths).toContain('/features/theme')
+      // No entry leaks from a build/dependency or hidden directory
+      for (const excluded of [
+        '.mdsite',
+        'node_modules',
+        'dist',
+        '.nuxt',
+        '.output',
+        '.nitro',
+        '.data',
+        '.git',
+        '.vscode',
+        '.idea',
+        '.history',
+        '.cache'
+      ]) {
+        expect(paths.some((p: string) => p.split('/').includes(excluded))).toBe(false)
+      }
+      const noH1Warnings = warnSpy.mock.calls
+        .map((call) => String(call[0] ?? ''))
+        .filter((line) => line.startsWith('⚠️'))
+      expect(noH1Warnings).toEqual([])
+    })
+
+    it('excludes build/dependency and hidden directories from the fallback navigation tree', async () => {
+      await plantMixedTree()
+
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+      try {
+        await generateNavigationJson()
+      } finally {
+        warnSpy.mockRestore()
+      }
+
+      const navigation = await readNavigation()
+      const paths = navigation.map((n: { path: string }) => n.path)
+      expect(paths).toContain('/')
+      expect(paths).toContain('/guide')
+      expect(paths).toContain('/features/theme')
+      // No node should be derived from a build/dependency or hidden directory
+      for (const excluded of [
+        '.mdsite',
+        'node_modules',
+        'dist',
+        '.nuxt',
+        '.output',
+        '.nitro',
+        '.data',
+        '.git',
+        '.vscode',
+        '.idea',
+        '.history',
+        '.cache'
+      ]) {
+        expect(paths.some((p: string) => p.split('/').includes(excluded))).toBe(false)
+      }
+
+      const noH1Warnings = warnSpy.mock.calls
+        .map((call) => String(call[0] ?? ''))
+        .filter((line) => line.startsWith('⚠️'))
+      expect(noH1Warnings).toEqual([])
+    })
+  })
 })

package/mdsite-nuxt/scripts/generate-indices.ts

@@ -836,7 +836,29 @@ function filePathToUrlPath(filePath: string, sourceDir: string): string {
 }
 
 /**
- * Get all markdown files recursively
+ * Directory names that are never user-authored content. The recursive
+ * markdown walker skips these so a content directory that happens to be
+ * the project root (i.e. `mdsite.yml` lives at the repo root and
+ * `paths.input` is unset) does not crawl into the renderer working dir
+ * (`.mdsite/`), its `node_modules`, or other build/dependency artifacts.
+ *
+ * The rule is broad on purpose: any directory whose name starts with `.`
+ * (hidden dirs like `.git`, `.mdsite`, `.nuxt`, `.vscode`, `.idea`,
+ * `.history`, `.data`, `.output`, …) plus the two non-hidden directories
+ * that are always tooling artifacts (`node_modules`, `dist`). Keeping the
+ * list narrow would require enumerating every CI/editor/build tool that
+ * might leave a hidden directory next to the content.
+ *
+ * Keep this in sync with the Nuxt Content collection `exclude` list in
+ * `content.config.ts` — both are the same safety net at two layers.
+ */
+function isExcludedSourceDir(name: string): boolean {
+    return name.startsWith('.') || name === 'node_modules' || name === 'dist'
+}
+
+/**
+ * Get all markdown files recursively, skipping build/dependency directories
+ * (see `isExcludedSourceDir`).
  */
 async function getAllMarkdownFiles(dir: string): Promise<string[]> {
     const files: string[] = []
@@ -852,6 +874,9 @@ async function getAllMarkdownFiles(dir: string): Promise<string[]> {
         const stat = await fs.stat(itemPath)
 
         if (stat.isDirectory()) {
+            if (isExcludedSourceDir(item)) {
+                continue
+            }
             const subFiles = await getAllMarkdownFiles(itemPath)
             files.push(...subFiles)
         } else if (item.endsWith('.md') && !item.endsWith('.draft.md')) {

package/mdsite-nuxt/scripts/sync-content.ts

@@ -209,9 +209,22 @@ export async function startWatcher() {
         `${sourceDir}/**/*.md`            // Watch all markdown files
     ]
 
+    // Skip build/dependency directories (see `isExcludedSourceDir`). The
+    // matcher inspects every path segment so a hidden dir or
+    // `node_modules`/`dist` nested anywhere under the content dir is
+    // ignored, regardless of depth.
+    const ignored = (filePath: string, stats?: { isDirectory?: () => boolean }) => {
+        if (stats?.isDirectory && stats.isDirectory()) {
+            return isExcludedSourceDir(path.basename(filePath))
+        }
+        const segments = filePath.split(path.sep)
+        return segments.some((segment) => isExcludedSourceDir(segment))
+    }
+
     const watcher = chokidar.watch(patterns, {
         persistent: true,
         ignoreInitial: true, // Files already copied above
+        ignored,
         awaitWriteFinish: {
             stabilityThreshold: 500,
             pollInterval: 100
@@ -361,7 +374,29 @@ async function isDraftOnlyImage(imagePath: string): Promise<boolean> {
 }
 
 /**
- * Get all files with specific extension recursively
+ * Directory names that are never user-authored content. The recursive image
+ * walker and the dev-mode file watcher both skip these so a content
+ * directory that happens to be the project root (i.e. `mdsite.yml` lives
+ * at the repo root and `paths.input` is unset) does not crawl into the
+ * renderer working dir (`.mdsite/`), its `node_modules`, or other
+ * build/dependency artifacts.
+ *
+ * The rule is broad on purpose: any directory whose name starts with `.`
+ * (hidden dirs like `.git`, `.mdsite`, `.nuxt`, `.vscode`, `.idea`,
+ * `.history`, `.data`, `.output`, …) plus the two non-hidden directories
+ * that are always tooling artifacts (`node_modules`, `dist`).
+ *
+ * Keep this in sync with the same predicate in
+ * `scripts/generate-indices.ts` and the Nuxt Content collection `exclude`
+ * list in `content.config.ts`.
+ */
+function isExcludedSourceDir(name: string): boolean {
+    return name.startsWith('.') || name === 'node_modules' || name === 'dist'
+}
+
+/**
+ * Get all files with specific extension recursively, skipping
+ * build/dependency directories (see `isExcludedSourceDir`).
  */
 async function getAllFiles(dir: string, ext: string): Promise<string[]> {
     const files: string[] = []
@@ -377,6 +412,9 @@ async function getAllFiles(dir: string, ext: string): Promise<string[]> {
         const stat = await fs.stat(itemPath)
 
         if (stat.isDirectory()) {
+            if (isExcludedSourceDir(item)) {
+                continue
+            }
             const subFiles = await getAllFiles(itemPath, ext)
             files.push(...subFiles)
         } else if (item.toLowerCase().endsWith(`.${ext}`)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@life-and-dev/mdsite",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "type": "module",
   "private": false,
   "description": "Local-first CLI that orchestrates mdsite-nuxt",