@nuasite/cms 0.18.0 → 0.19.0

package/src/source-finder/collection-finder.ts

@@ -1,8 +1,9 @@
 import fs from 'node:fs/promises'
 import path from 'node:path'
-import { isMap, isPair, isScalar, LineCounter, parseDocument } from 'yaml'
+import { isMap, isPair, isScalar, isSeq, LineCounter, parseDocument } from 'yaml'
 
 import { getProjectRoot } from '../config'
+import type { CollectionDefinition } from '../types'
 import { getMarkdownFileCache } from './cache'
 import { normalizeText } from './snippet-utils'
 import type { CollectionInfo, MarkdownContent, SourceLocation } from './types'
@@ -194,63 +195,240 @@ export async function findMarkdownSourceLocation(
 		const { lines } = cached
 		const normalizedSearch = normalizeText(textContent)
 
-		// Parse frontmatter
+		// Find frontmatter boundaries
+		let frontmatterStart = -1
 		let frontmatterEnd = -1
-		let inFrontmatter = false
-
 		for (let i = 0; i < lines.length; i++) {
-			const line = lines[i]?.trim()
-			if (line === '---') {
-				if (!inFrontmatter) {
-					inFrontmatter = true
+			if (lines[i]?.trim() === '---') {
+				if (frontmatterStart === -1) {
+					frontmatterStart = i
 				} else {
 					frontmatterEnd = i
 					break
 				}
 			}
 		}
+		if (frontmatterEnd <= 0) return undefined
 
-		// Search in frontmatter only (for title, subtitle, etc.)
-		if (frontmatterEnd > 0) {
-			for (let i = 1; i < frontmatterEnd; i++) {
-				const line = lines[i]
-				if (!line) continue
-
-				// Extract value from YAML key: value (keys can contain hyphens)
-				const match = line.match(/^\s*([\w-]+):\s*(.+)$/)
-				if (match) {
-					const key = match[1]
-					let value = match[2]?.trim() || ''
-
-					// Handle quoted strings
-					if (
-						(value.startsWith('"') && value.endsWith('"'))
-						|| (value.startsWith("'") && value.endsWith("'"))
-					) {
-						value = value.slice(1, -1)
-					}
+		const yamlStr = lines.slice(frontmatterStart + 1, frontmatterEnd).join('\n')
+		const lineOffset = frontmatterStart + 1
+		return findScalarInYamlAst(yamlStr, lineOffset, normalizedSearch, lines, collectionInfo)
+	} catch {
+		// Error reading file
+	}
 
-					if (normalizeText(value) === normalizedSearch) {
-						return {
-							file: collectionInfo.file,
-							line: i + 1,
-							snippet: line,
-							type: 'collection',
-							variableName: key,
-							collectionName: collectionInfo.name,
-							collectionSlug: collectionInfo.slug,
-						}
-					}
-				}
+	return undefined
+}
+
+/**
+ * Search all collection entries for a text value across all formats
+ * (markdown frontmatter, JSON, YAML data files).
+ */
+export async function findTextInAnyCollectionFrontmatter(
+	textContent: string,
+	collections: Record<string, CollectionDefinition>,
+): Promise<SourceLocation | undefined> {
+	const normalizedSearch = normalizeText(textContent)
+
+	for (const def of Object.values(collections)) {
+		if (!def.entries || def.entries.length === 0) continue
+
+		for (const entry of def.entries) {
+			const info: CollectionInfo = { name: def.name, slug: entry.slug, file: entry.sourcePath }
+
+			if (def.type === 'data') {
+				const result = await findTextInDataFile(normalizedSearch, info)
+				if (result) return result
+			} else {
+				const result = await findMarkdownSourceLocation(textContent, info)
+				if (result) return result
 			}
 		}
+	}
+	return undefined
+}
+
+/**
+ * Search a data file (JSON, YAML, YML) for a scalar value using AST parsing.
+ * JSON is valid YAML, so parseDocument handles all formats uniformly.
+ */
+async function findTextInDataFile(
+	normalizedSearch: string,
+	collectionInfo: CollectionInfo,
+): Promise<SourceLocation | undefined> {
+	try {
+		const filePath = path.join(getProjectRoot(), collectionInfo.file)
+		const cached = await getCachedMarkdownFile(filePath)
+		if (!cached) return undefined
 
-		// Body content is not searched line-by-line anymore
-		// Use parseMarkdownContent to get the full body as one entry
+		return findScalarInYamlAst(cached.content, 0, normalizedSearch, cached.lines, collectionInfo)
 	} catch {
 		// Error reading file
 	}
+	return undefined
+}
 
+/**
+ * Walk a YAML AST to find a scalar value matching the search text.
+ * Handles nested maps and sequences.
+ */
+function findScalarInYamlAst(
+	yamlStr: string,
+	lineOffset: number,
+	normalizedSearch: string,
+	fileLines: string[],
+	collectionInfo: CollectionInfo,
+): SourceLocation | undefined {
+	const lineCounter = new LineCounter()
+	const doc = parseDocument(yamlStr, { lineCounter })
+
+	const found = walkYamlNode(doc.contents, normalizedSearch, lineCounter)
+	if (!found) return undefined
+
+	const fileStartLine = found.startLine + lineOffset
+	const fileEndLine = found.endLine + lineOffset
+
+	// Build snippet spanning all lines of the key-value pair (handles multi-line YAML values)
+	const snippet = fileLines.slice(fileStartLine - 1, fileEndLine).join('\n')
+
+	return {
+		file: collectionInfo.file,
+		line: fileStartLine,
+		snippet,
+		type: 'collection',
+		variableName: found.key,
+		collectionName: collectionInfo.name,
+		collectionSlug: collectionInfo.slug,
+	}
+}
+
+/** Recursively walk a YAML node to find a scalar matching the search text */
+function walkYamlNode(
+	node: unknown,
+	normalizedSearch: string,
+	lineCounter: LineCounter,
+): { key: string | undefined; startLine: number; endLine: number } | undefined {
+	if (isMap(node)) {
+		for (const pair of node.items) {
+			if (!isPair(pair) || !isScalar(pair.key)) continue
+			const key = String(pair.key.value)
+
+			if (isScalar(pair.value)) {
+				if (normalizeText(String(pair.value.value)) === normalizedSearch) {
+					const keyRange = (pair.key as any).range as [number, number, number] | undefined
+					const valRange = (pair.value as any).range as [number, number, number] | undefined
+					const startLine = keyRange ? lineCounter.linePos(keyRange[0]).line : 1
+					const endLine = valRange ? lineCounter.linePos(valRange[1]).line : startLine
+					return { key, startLine, endLine }
+				}
+			} else {
+				// Recurse into nested maps/sequences
+				const nested = walkYamlNode(pair.value, normalizedSearch, lineCounter)
+				if (nested) return nested
+			}
+		}
+	} else if (isSeq(node)) {
+		for (const item of node.items) {
+			if (isScalar(item)) {
+				if (normalizeText(String(item.value)) === normalizedSearch) {
+					const range = (item as any).range as [number, number, number] | undefined
+					const startLine = range ? lineCounter.linePos(range[0]).line : 1
+					const endLine = range ? lineCounter.linePos(range[1]).line : startLine
+					return { key: undefined, startLine, endLine }
+				}
+			} else {
+				const nested = walkYamlNode(item, normalizedSearch, lineCounter)
+				if (nested) return nested
+			}
+		}
+	}
+	return undefined
+}
+
+/**
+ * Find an image field by name in a specific collection entry's data file.
+ * Used when the rendered image URL has been transformed (e.g., Astro hashed filenames)
+ * and can't be matched by value, but we know the field name from the expression.
+ */
+export async function findFieldInCollectionEntry(
+	fieldName: string,
+	collectionName: string,
+	collectionSlug: string,
+	collectionDefinitions: Record<string, CollectionDefinition>,
+): Promise<SourceLocation | undefined> {
+	const def = collectionDefinitions[collectionName]
+	if (!def?.entries) return undefined
+
+	const entry = def.entries.find((e) => e.slug === collectionSlug)
+	if (!entry) return undefined
+
+	const info: CollectionInfo = { name: collectionName, slug: collectionSlug, file: entry.sourcePath }
+
+	try {
+		const filePath = path.join(getProjectRoot(), entry.sourcePath)
+		const cached = await getCachedMarkdownFile(filePath)
+		if (!cached) return undefined
+
+		if (def.type === 'data') {
+			return findFieldByNameInYaml(cached.content, 0, fieldName, cached.lines, info)
+		}
+
+		// For markdown, search inside frontmatter only
+		const { lines } = cached
+		let fmStart = -1
+		let fmEnd = -1
+		for (let i = 0; i < lines.length; i++) {
+			if (lines[i]?.trim() === '---') {
+				if (fmStart === -1) fmStart = i
+				else {
+					fmEnd = i
+					break
+				}
+			}
+		}
+		if (fmEnd <= 0) return undefined
+		const yamlStr = lines.slice(fmStart + 1, fmEnd).join('\n')
+		return findFieldByNameInYaml(yamlStr, fmStart + 1, fieldName, lines, info)
+	} catch {
+		return undefined
+	}
+}
+
+/**
+ * Walk a YAML AST to find a field by key name (regardless of its value).
+ */
+function findFieldByNameInYaml(
+	yamlStr: string,
+	lineOffset: number,
+	fieldName: string,
+	fileLines: string[],
+	collectionInfo: CollectionInfo,
+): SourceLocation | undefined {
+	const lineCounter = new LineCounter()
+	const doc = parseDocument(yamlStr, { lineCounter })
+	if (!isMap(doc.contents)) return undefined
+
+	for (const pair of doc.contents.items) {
+		if (!isPair(pair) || !isScalar(pair.key)) continue
+		if (String(pair.key.value) !== fieldName) continue
+		if (!isScalar(pair.value)) continue
+
+		const keyRange = (pair.key as any).range as [number, number, number] | undefined
+		const valRange = (pair.value as any).range as [number, number, number] | undefined
+		const startLine = (keyRange ? lineCounter.linePos(keyRange[0]).line : 1) + lineOffset
+		const endLine = (valRange ? lineCounter.linePos(valRange[1]).line : startLine - lineOffset) + lineOffset
+
+		const snippet = fileLines.slice(startLine - 1, endLine).join('\n')
+		return {
+			file: collectionInfo.file,
+			line: startLine,
+			snippet,
+			type: 'collection',
+			variableName: fieldName,
+			collectionName: collectionInfo.name,
+			collectionSlug: collectionInfo.slug,
+		}
+	}
 	return undefined
 }
 

package/src/source-finder/index.ts

@@ -23,7 +23,13 @@ export { findAttributeSourceLocation } from './cross-file-tracker'
 export { findImageSourceLocation } from './image-finder'
 
 // Collection/markdown finding
-export { findCollectionSource, findMarkdownSourceLocation, parseMarkdownContent } from './collection-finder'
+export {
+	findCollectionSource,
+	findFieldInCollectionEntry,
+	findMarkdownSourceLocation,
+	findTextInAnyCollectionFrontmatter,
+	parseMarkdownContent,
+} from './collection-finder'
 
 // Snippet utilities (used by html-processor)
 export {

package/src/source-finder/search-index.ts

@@ -16,7 +16,14 @@ import {
 	setSearchIndexInitialized,
 } from './cache'
 import { extractImageSnippet, extractInnerHtmlFromSnippet, normalizeText } from './snippet-utils'
-import type { CachedParsedFile, SourceLocation } from './types'
+import type { CachedParsedFile, SearchIndexEntry, SourceLocation } from './types'
+
+/** Collection data files live under this path — used to prefer them over templates */
+const CONTENT_DIR_PREFIX = 'src/content/'
+
+function isCollectionFile(file: string): boolean {
+	return file.includes(CONTENT_DIR_PREFIX)
+}
 
 // ============================================================================
 // File Collection
@@ -56,13 +63,26 @@ export async function collectAstroFiles(dir: string): Promise<string[]> {
 // Index Initialization
 // ============================================================================
 
+/** Shared promise so concurrent callers wait for the same initialization */
+let initPromise: Promise<void> | null = null
+
 /**
  * Initialize search index by pre-scanning all source files.
  * This is much faster than searching per-entry.
+ * Safe to call concurrently — all callers share the same initialization.
  */
 export async function initializeSearchIndex(): Promise<void> {
 	if (isSearchIndexInitialized()) return
+	if (initPromise) return initPromise
+	initPromise = doInitializeSearchIndex()
+	try {
+		await initPromise
+	} finally {
+		initPromise = null
+	}
+}
 
+async function doInitializeSearchIndex(): Promise<void> {
 	const srcDir = path.join(getProjectRoot(), 'src')
 	const searchDirs = [
 		path.join(srcDir, 'components'),
@@ -99,6 +119,9 @@ export async function initializeSearchIndex(): Promise<void> {
 		}
 	}))
 
+	// Index image-like values from content collection data files (JSON/YAML)
+	await indexContentCollectionImages()
+
 	setSearchIndexInitialized(true)
 }
 
@@ -529,6 +552,117 @@ export function indexFileImages(cached: CachedParsedFile, relFile: string): void
 	}
 }
 
+// ============================================================================
+// Content Collection Data File Indexing
+// ============================================================================
+
+/** Image-like file extensions to match in data file values */
+const IMAGE_EXTENSIONS = /\.(jpe?g|png|gif|webp|avif|svg|ico|bmp|tiff?)$/i
+
+/**
+ * Index image paths found in content collection data files (JSON/YAML).
+ * These are values like `"image": "/assets/photo.webp"` that get rendered
+ * through template expressions (e.g., `src={person.image}`).
+ */
+async function indexContentCollectionImages(): Promise<void> {
+	const contentDir = path.join(getProjectRoot(), 'src', 'content')
+	const entries = await fs.readdir(contentDir, { withFileTypes: true }).catch(() => null)
+	if (!entries) return // No content directory
+
+	const dataFiles: string[] = []
+	for (const entry of entries) {
+		if (entry.isDirectory()) {
+			await collectDataFiles(path.join(contentDir, entry.name), dataFiles)
+		}
+	}
+
+	await Promise.all(dataFiles.map(async (filePath) => {
+		try {
+			const content = await fs.readFile(filePath, 'utf-8')
+			const relFile = path.relative(getProjectRoot(), filePath)
+
+			if (filePath.endsWith('.json')) {
+				indexJsonImages(content, relFile)
+			} else if (filePath.endsWith('.yaml') || filePath.endsWith('.yml')) {
+				indexYamlImages(content, relFile)
+			} else if (filePath.endsWith('.md') || filePath.endsWith('.mdx')) {
+				indexFrontmatterImages(content, relFile)
+			}
+		} catch {
+			// Skip unreadable files
+		}
+	}))
+}
+
+const DATA_FILE_PATTERN = /\.(json|ya?ml|mdx?)$/
+
+async function collectDataFiles(dir: string, results: string[]): Promise<void> {
+	try {
+		const entries = await fs.readdir(dir, { withFileTypes: true })
+		await Promise.all(entries.map(async (entry) => {
+			const fullPath = path.join(dir, entry.name)
+			if (entry.isDirectory()) {
+				await collectDataFiles(fullPath, results)
+			} else if (entry.isFile() && DATA_FILE_PATTERN.test(entry.name)) {
+				results.push(fullPath)
+			}
+		}))
+	} catch {
+		// Directory doesn't exist
+	}
+}
+
+function indexJsonImages(content: string, relFile: string): void {
+	const lines = content.split('\n')
+	// Match JSON string values that look like image paths
+	const pattern = /:\s*"([^"]+)"/g
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i]!
+		let match
+		pattern.lastIndex = 0
+		while ((match = pattern.exec(line)) !== null) {
+			const value = match[1]!
+			if (IMAGE_EXTENSIONS.test(value)) {
+				addToImageSearchIndex({
+					file: relFile,
+					line: i + 1,
+					snippet: line.trim(),
+					src: value,
+				})
+			}
+		}
+	}
+}
+
+function indexYamlImages(content: string, relFile: string): void {
+	indexYamlLikeLines(content.split('\n'), relFile, 0)
+}
+
+function indexFrontmatterImages(content: string, relFile: string): void {
+	// Only scan YAML frontmatter (between --- markers)
+	const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/)
+	if (!fmMatch) return
+	indexYamlLikeLines(fmMatch[1]!.split('\n'), relFile, 1)
+}
+
+/** Shared YAML key-value image scanner used by both indexYamlImages and indexFrontmatterImages */
+function indexYamlLikeLines(lines: string[], relFile: string, lineOffset: number): void {
+	const pattern = /^\s*[\w-]+:\s*(.+)/
+	for (let i = 0; i < lines.length; i++) {
+		const match = lines[i]!.match(pattern)
+		if (!match) continue
+		const value = match[1]!.trim().replace(/^['"]|['"]$/g, '')
+		if (IMAGE_EXTENSIONS.test(value)) {
+			addToImageSearchIndex({
+				file: relFile,
+				line: i + 1 + lineOffset,
+				snippet: lines[i]!.trim(),
+				src: value,
+			})
+		}
+	}
+}
+
 // ============================================================================
 // Index Lookup
 // ============================================================================
@@ -541,55 +675,51 @@ export function findInTextIndex(textContent: string, tag: string): SourceLocatio
 	const tagLower = tag.toLowerCase()
 	const index = getTextSearchIndex()
 
-	// First try exact match with same tag
+	// Helper to build SourceLocation from a text index entry
+	const toLocation = (entry: SearchIndexEntry): SourceLocation => ({
+		file: entry.file,
+		line: entry.line,
+		snippet: entry.snippet,
+		openingTagSnippet: entry.openingTagSnippet,
+		type: entry.type,
+		variableName: entry.variableName,
+		definitionLine: entry.definitionLine,
+	})
+
+	// First try exact match with same tag — prefer collection data files
+	let bestMatch: SourceLocation | undefined
 	for (const entry of index) {
 		if (entry.tag === tagLower && entry.normalizedText === normalizedSearch) {
-			return {
-				file: entry.file,
-				line: entry.line,
-				snippet: entry.snippet,
-				openingTagSnippet: entry.openingTagSnippet,
-				type: entry.type,
-				variableName: entry.variableName,
-				definitionLine: entry.definitionLine,
-			}
+			const result = toLocation(entry)
+			if (isCollectionFile(entry.file)) return result
+			bestMatch ??= result
 		}
 	}
+	if (bestMatch) return bestMatch
 
-	// Then try partial match for longer text
+	// Then try partial match for longer text — prefer collection data files
 	if (normalizedSearch.length > 10) {
 		const textPreview = normalizedSearch.slice(0, Math.min(30, normalizedSearch.length))
 		for (const entry of index) {
 			if (entry.tag === tagLower && entry.normalizedText.includes(textPreview)) {
-				return {
-					file: entry.file,
-					line: entry.line,
-					snippet: entry.snippet,
-					openingTagSnippet: entry.openingTagSnippet,
-					type: entry.type,
-					variableName: entry.variableName,
-					definitionLine: entry.definitionLine,
-				}
+				const result = toLocation(entry)
+				if (isCollectionFile(entry.file)) return result
+				bestMatch ??= result
 			}
 		}
+		if (bestMatch) return bestMatch
 	}
 
-	// Try any tag match
+	// Try any tag match — prefer collection data files
 	for (const entry of index) {
 		if (entry.normalizedText === normalizedSearch) {
-			return {
-				file: entry.file,
-				line: entry.line,
-				snippet: entry.snippet,
-				openingTagSnippet: entry.openingTagSnippet,
-				type: entry.type,
-				variableName: entry.variableName,
-				definitionLine: entry.definitionLine,
-			}
+			const result = toLocation(entry)
+			if (isCollectionFile(entry.file)) return result
+			bestMatch ??= result
 		}
 	}
 
-	return undefined
+	return bestMatch
 }
 
 /**
@@ -609,17 +739,25 @@ function extractPathname(src: string): string {
 export function findInImageIndex(imageSrc: string): SourceLocation | undefined {
 	const index = getImageSearchIndex()
 
-	// Exact match first
+	// Exact match — prefer collection data files (src/content/) over templates.
+	// The same image URL can appear in both a collection data file and a template
+	// that statically renders the collection. The data file is the authoritative source.
+	let bestMatch: SourceLocation | undefined
 	for (const entry of index) {
 		if (entry.src === imageSrc) {
-			return {
+			const result: SourceLocation = {
 				file: entry.file,
 				line: entry.line,
 				snippet: entry.snippet,
 				type: 'static',
 			}
+			if (isCollectionFile(entry.file)) {
+				return result // Collection data file — always preferred
+			}
+			bestMatch ??= result // Keep first non-collection match as fallback
 		}
 	}
+	if (bestMatch) return bestMatch
 
 	// Fallback: path suffix matching for CDN-transformed URLs
 	// e.g., rendered src "/cdn-cgi/image/.../assets/photo.webp" should match
@@ -628,14 +766,18 @@ export function findInImageIndex(imageSrc: string): SourceLocation | undefined {
 	for (const entry of index) {
 		const entryPath = extractPathname(entry.src)
 		if (entryPath.length > 5 && (targetPath.endsWith(entryPath) || entryPath.endsWith(targetPath))) {
-			return {
+			const result: SourceLocation = {
 				file: entry.file,
 				line: entry.line,
 				snippet: entry.snippet,
 				type: 'static',
 			}
+			if (isCollectionFile(entry.file)) {
+				return result
+			}
+			bestMatch ??= result
 		}
 	}
 
-	return undefined
+	return bestMatch
 }