@nuasite/cms 0.19.1 → 0.20.2

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

@@ -8,6 +8,187 @@ import { getMarkdownFileCache } from './cache'
 import { normalizeText } from './snippet-utils'
 import type { CollectionInfo, MarkdownContent, SourceLocation } from './types'
 
+// ============================================================================
+// Collection Text Index — pre-built reverse index for fast text→source lookups
+// ============================================================================
+
+/** Pre-built index: normalizedText → SourceLocation (with collection metadata) */
+let collectionTextIndex: Map<string, SourceLocation[]> | null = null
+let collectionTextIndexPromise: Promise<void> | null = null
+
+/**
+ * Build a reverse index of all text values in collection data/frontmatter files.
+ * After this call, `lookupCollectionText()` returns results in O(1).
+ */
+export async function buildCollectionTextIndex(
+	collections: Record<string, CollectionDefinition>,
+): Promise<void> {
+	if (collectionTextIndex) return
+	if (collectionTextIndexPromise) return collectionTextIndexPromise
+	collectionTextIndexPromise = doBuildCollectionTextIndex(collections)
+	try {
+		await collectionTextIndexPromise
+	} finally {
+		collectionTextIndexPromise = null
+	}
+}
+
+async function doBuildCollectionTextIndex(
+	collections: Record<string, CollectionDefinition>,
+): Promise<void> {
+	const index = new Map<string, SourceLocation[]>()
+
+	for (const def of Object.values(collections)) {
+		if (!def.entries || def.entries.length === 0) continue
+
+		await Promise.all(def.entries.map(async (entry) => {
+			const info: CollectionInfo = { name: def.name, slug: entry.slug, file: entry.sourcePath }
+			try {
+				const filePath = path.join(getProjectRoot(), entry.sourcePath)
+				const cached = await getCachedMarkdownFile(filePath)
+				if (!cached) return
+
+				if (def.type === 'data') {
+					// Data file — index all scalars from the full YAML
+					collectScalarsFromYaml(cached.content, 0, cached.lines, info, index)
+				} else {
+					// Markdown — index scalars from 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) {
+						const yamlStr = lines.slice(fmStart + 1, fmEnd).join('\n')
+						collectScalarsFromYaml(yamlStr, fmStart + 1, lines, info, index)
+					}
+				}
+			} catch {
+				// Skip unreadable files
+			}
+		}))
+	}
+
+	collectionTextIndex = index
+}
+
+/**
+ * Walk a YAML document and collect all scalar values into the text index.
+ */
+function collectScalarsFromYaml(
+	yamlStr: string,
+	lineOffset: number,
+	fileLines: string[],
+	collectionInfo: CollectionInfo,
+	index: Map<string, SourceLocation[]>,
+): void {
+	const lineCounter = new LineCounter()
+	const doc = parseDocument(yamlStr, { lineCounter })
+	collectFromYamlNode(doc.contents, lineOffset, fileLines, collectionInfo, lineCounter, index)
+}
+
+function collectFromYamlNode(
+	node: unknown,
+	lineOffset: number,
+	fileLines: string[],
+	collectionInfo: CollectionInfo,
+	lineCounter: LineCounter,
+	index: Map<string, SourceLocation[]>,
+): void {
+	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)) {
+				const normalized = normalizeText(String(pair.value.value))
+				if (normalized.length < 2) 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')
+
+				const loc: SourceLocation = {
+					file: collectionInfo.file,
+					line: startLine,
+					snippet,
+					type: 'collection',
+					variableName: key,
+					collectionName: collectionInfo.name,
+					collectionSlug: collectionInfo.slug,
+				}
+				const existing = index.get(normalized)
+				if (existing) existing.push(loc)
+				else index.set(normalized, [loc])
+			} else {
+				collectFromYamlNode(pair.value, lineOffset, fileLines, collectionInfo, lineCounter, index)
+			}
+		}
+	} else if (isSeq(node)) {
+		for (const item of node.items) {
+			if (isScalar(item)) {
+				const normalized = normalizeText(String(item.value))
+				if (normalized.length < 2) continue
+				const range = (item as any).range as [number, number, number] | undefined
+				const startLine = (range ? lineCounter.linePos(range[0]).line : 1) + lineOffset
+				const endLine = (range ? lineCounter.linePos(range[1]).line : startLine - lineOffset) + lineOffset
+				const snippet = fileLines.slice(startLine - 1, endLine).join('\n')
+
+				const loc: SourceLocation = {
+					file: collectionInfo.file,
+					line: startLine,
+					snippet,
+					type: 'collection',
+					collectionName: collectionInfo.name,
+					collectionSlug: collectionInfo.slug,
+				}
+				const existing = index.get(normalized)
+				if (existing) existing.push(loc)
+				else index.set(normalized, [loc])
+			} else {
+				collectFromYamlNode(item, lineOffset, fileLines, collectionInfo, lineCounter, index)
+			}
+		}
+	}
+}
+
+/**
+ * O(1) lookup in the pre-built collection text index.
+ * Returns all matching source locations, preferring referenced collections.
+ */
+export function lookupCollectionText(
+	textContent: string,
+	referenceIndex?: Map<string, Array<{ collection: string; fieldName: string; isArray?: boolean }>>,
+): SourceLocation | undefined {
+	if (!collectionTextIndex) return undefined
+	const normalized = normalizeText(textContent)
+	const locations = collectionTextIndex.get(normalized)
+	if (!locations || locations.length === 0) return undefined
+
+	// Prefer locations from referenced collections
+	if (referenceIndex) {
+		for (const loc of locations) {
+			if (loc.collectionName && referenceIndex.has(loc.collectionName)) {
+				return loc
+			}
+		}
+	}
+	return locations[0]
+}
+
+/** Clear the collection text index (called when collection files change) */
+export function clearCollectionTextIndex(): void {
+	collectionTextIndex = null
+}
+
 // ============================================================================
 // Markdown File Cache
 // ============================================================================

package/src/source-finder/index.ts

@@ -8,10 +8,10 @@
 export type { CollectionInfo, MarkdownContent, SourceLocation, VariableReference } from './types'
 
 // Cache management
-export { clearSourceFinderCache } from './cache'
+export { clearSourceFinderCache, markFileDirty } from './cache'
 
 // Search index
-export { initializeSearchIndex } from './search-index'
+export { initializeSearchIndex, reindexDirtyFiles } from './search-index'
 
 // Source location finding
 export { findSourceLocation } from './source-lookup'
@@ -24,10 +24,13 @@ export { findImageSourceLocation } from './image-finder'
 
 // Collection/markdown finding
 export {
+	buildCollectionTextIndex,
+	clearCollectionTextIndex,
 	findCollectionSource,
 	findFieldInCollectionEntry,
 	findMarkdownSourceLocation,
 	findTextInAnyCollectionFrontmatter,
+	lookupCollectionText,
 	parseMarkdownContent,
 } from './collection-finder'
 

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

@@ -9,12 +9,17 @@ import { getCachedParsedFile } from './ast-parser'
 import {
 	addToImageSearchIndex,
 	addToTextSearchIndex,
+	clearDirtyFiles,
 	getDirectoryCache,
+	getDirtyFiles,
 	getImageSearchIndex,
+	getMarkdownFileCache,
 	getTextSearchIndex,
 	isSearchIndexInitialized,
+	removeFileFromIndexes,
 	setSearchIndexInitialized,
 } from './cache'
+import { clearCollectionTextIndex } from './collection-finder'
 import { extractImageSnippet, extractInnerHtmlFromSnippet, normalizeText } from './snippet-utils'
 import type { CachedParsedFile, SearchIndexEntry, SourceLocation } from './types'
 
@@ -125,6 +130,80 @@ async function doInitializeSearchIndex(): Promise<void> {
 	setSearchIndexInitialized(true)
 }
 
+// ============================================================================
+// Incremental Re-indexing
+// ============================================================================
+
+/** Shared promise so concurrent callers wait for the same re-indexing */
+let reindexPromise: Promise<void> | null = null
+
+/**
+ * Re-index only files that changed since the last indexing.
+ * Much faster than a full rebuild — only re-parses dirty files.
+ * Safe to call concurrently — all callers share the same operation.
+ *
+ * Also clears the markdown file cache so collection content is re-read.
+ */
+export async function reindexDirtyFiles(): Promise<void> {
+	const dirty = getDirtyFiles()
+	if (dirty.size === 0) return
+	if (reindexPromise) return reindexPromise
+	reindexPromise = doReindexDirtyFiles()
+	try {
+		await reindexPromise
+	} finally {
+		reindexPromise = null
+	}
+}
+
+async function doReindexDirtyFiles(): Promise<void> {
+	const dirty = getDirtyFiles()
+	if (dirty.size === 0) return
+
+	const projectRoot = getProjectRoot()
+	const filesToReindex = [...dirty]
+	clearDirtyFiles()
+
+	// Also clear the markdown file cache and collection text index
+	// so collection content is re-read and re-indexed from disk
+	getMarkdownFileCache().clear()
+	clearCollectionTextIndex()
+
+	for (const absPath of filesToReindex) {
+		const relFile = path.relative(projectRoot, absPath)
+
+		// Remove old entries for this file
+		removeFileFromIndexes(relFile)
+
+		// Re-parse and re-index if it's a source file
+		if (absPath.endsWith('.astro') || absPath.endsWith('.tsx') || absPath.endsWith('.jsx')) {
+			try {
+				const cached = await getCachedParsedFile(absPath)
+				if (cached) {
+					indexFileContent(cached, relFile)
+					indexFileImages(cached, relFile)
+				}
+			} catch {
+				// Skip files that fail to parse
+			}
+		} else if (/\.(json|ya?ml|mdx?)$/.test(absPath)) {
+			// Content collection data file — re-index images from it
+			try {
+				const content = await fs.readFile(absPath, 'utf-8')
+				if (absPath.endsWith('.json')) {
+					indexJsonImages(content, relFile)
+				} else if (absPath.endsWith('.yaml') || absPath.endsWith('.yml')) {
+					indexYamlImages(content, relFile)
+				} else if (absPath.endsWith('.md') || absPath.endsWith('.mdx')) {
+					indexFrontmatterImages(content, relFile)
+				}
+			} catch {
+				// Skip unreadable files
+			}
+		}
+	}
+}
+
 // ============================================================================
 // Content Indexing
 // ============================================================================

package/src/source-finder/snippet-utils.ts

@@ -7,7 +7,7 @@ import type { Attribute, CollectionDefinition, ManifestEntry } from '../types'
 import { escapeRegex, generateSourceHash } from '../utils'
 import { buildDefinitionPath } from './ast-extractors'
 import { getCachedParsedFile } from './ast-parser'
-import { findFieldInCollectionEntry, findTextInAnyCollectionFrontmatter } from './collection-finder'
+import { buildCollectionTextIndex, findFieldInCollectionEntry, findTextInAnyCollectionFrontmatter, lookupCollectionText } from './collection-finder'
 import { findAttributeSourceLocation, searchForExpressionProp, searchForPropInParents } from './cross-file-tracker'
 import { findImageElementNearLine, findImageSourceLocation } from './image-finder'
 import { initializeSearchIndex } from './search-index'
@@ -502,6 +502,11 @@ export async function enhanceManifestWithSourceSnippets(
 		}
 	}
 
+	// Build collection text index upfront for O(1) lookups in both entries and augment phases
+	if (collectionDefinitions && Object.keys(collectionDefinitions).length > 0) {
+		await buildCollectionTextIndex(collectionDefinitions)
+	}
+
 	// Propagate collectionName/collectionSlug from wrapper entries to their children.
 	// The HTML processor only sets collection info on the wrapper element itself;
 	// child entries (images, text) need it for direct data-file resolution.
@@ -531,6 +536,19 @@ export async function enhanceManifestWithSourceSnippets(
 		}
 	}
 
+	// Shared file read cache — avoids redundant fs.readFile calls
+	// when many entries share the same source file
+	const fileContentCache = new Map<string, { content: string; lines: string[] }>()
+	const readFileWithCache = async (filePath: string): Promise<{ content: string; lines: string[] }> => {
+		const cached = fileContentCache.get(filePath)
+		if (cached) return cached
+		const content = await fs.readFile(filePath, 'utf-8')
+		const lines = content.split('\n')
+		const result = { content, lines }
+		fileContentCache.set(filePath, result)
+		return result
+	}
+
 	// Process entries in parallel for better performance
 	const entryPromises = Object.entries(entries).map(async ([id, entry]) => {
 		// Handle image entries specially - find the line with src attribute
@@ -568,8 +586,7 @@ export async function enhanceManifestWithSourceSnippets(
 					const filePath = path.isAbsolute(imageLocation.file)
 						? imageLocation.file
 						: path.join(getProjectRoot(), imageLocation.file)
-					const content = await fs.readFile(filePath, 'utf-8')
-					const lines = content.split('\n')
+					const { lines } = await readFileWithCache(filePath)
 					const openingTagInfo = extractOpeningTagWithLine(lines, imageLocation.line - 1, entry.tag)
 
 					if (openingTagInfo) {
@@ -656,8 +673,7 @@ export async function enhanceManifestWithSourceSnippets(
 				? entry.sourcePath
 				: path.join(getProjectRoot(), entry.sourcePath)
 
-			const content = await fs.readFile(filePath, 'utf-8')
-			const lines = content.split('\n')
+			const { content, lines } = await readFileWithCache(filePath)
 
 			// Extract the complete source element
 			const sourceSnippet = extractCompleteTagSnippet(lines, entry.sourceLine - 1, entry.tag)
@@ -806,7 +822,7 @@ export async function enhanceManifestWithSourceSnippets(
 					// from collection entries (e.g. {post.data.title}) won't be found
 					// through AST or prop lookups since the value lives in a .md file
 					if (collectionDefinitions && Object.keys(collectionDefinitions).length > 0) {
-						const mdSource = await findTextInAnyCollectionFrontmatter(trimmedText, collectionDefinitions)
+						const mdSource = lookupCollectionText(trimmedText, referenceIndex)
 						if (mdSource) {
 							return [
 								id,
@@ -841,72 +857,31 @@ export async function enhanceManifestWithSourceSnippets(
 	for (const [id, entry] of results) {
 		enhanced[id] = entry
 	}
-
 	// Post-processing: augment entries with collection and reference metadata.
-	// Source resolution may find text via prop/expression tracking (pointing to a parent
-	// component) before the collection frontmatter search runs. In that case the source
-	// location is correct for editing, but collection identity and reference metadata are
-	// missing. This pass adds both by checking if text exists in any collection.
-	// collectionName/collectionSlug are needed on owning entries (e.g. news titles) so
-	// that findOwnerEntry in the editor can locate them as siblings of reference elements.
+	// Uses the pre-built collection text index for O(1) lookups instead of
+	// re-parsing YAML/frontmatter for every entry.
 	if (collectionDefinitions && Object.keys(collectionDefinitions).length > 0) {
-		// Cache text→result to avoid redundant file reads when the same text appears
-		// in multiple manifest entries (e.g., author names repeated on listing pages)
-		const textLookupCache = new Map<
-			string,
-			{ source: SourceLocation; referencedBy?: Array<{ collection: string; fieldName: string; isArray?: boolean }> } | null
-		>()
-
-		async function resolveCollectionText(trimmed: string) {
-			const cached = textLookupCache.get(trimmed)
-			if (cached !== undefined) return cached
-
-			// Search each collection individually so we can prefer referenced collections
-			// (findTextInAnyCollectionFrontmatter returns the first match, which may be wrong
-			// when the same text exists in multiple collections like "team" and "authors")
-			let bestSource: SourceLocation | undefined
-			let bestReferencedBy: Array<{ collection: string; fieldName: string; isArray?: boolean }> | undefined
-			for (const def of Object.values(collectionDefinitions!)) {
-				if (!def.entries || def.entries.length === 0) continue
-				const singleCol = { [def.name]: def }
-				const source = await findTextInAnyCollectionFrontmatter(trimmed, singleCol)
-				if (!source?.collectionName) continue
-				const refs = referenceIndex.get(source.collectionName)
-				if (refs && refs.length > 0) {
-					bestSource = source
-					bestReferencedBy = refs
-					break
-				}
-				if (!bestSource) {
-					bestSource = source
-				}
-			}
+		await buildCollectionTextIndex(collectionDefinitions)
 
-			const result = bestSource ? { source: bestSource, referencedBy: bestReferencedBy } : null
-			textLookupCache.set(trimmed, result)
-			return result
-		}
-
-		const augmentPromises = Object.entries(enhanced).map(async ([id, entry]) => {
-			if (!entry.text?.trim()) return
+		for (const [id, entry] of Object.entries(enhanced)) {
+			if (!entry.text?.trim()) continue
 			// Skip if already fully resolved (has collection identity + reference metadata or no references exist)
-			if (entry.collectionName && (entry.referenceCollection || referenceIndex.size === 0)) return
-			const trimmed = entry.text.trim()
+			if (entry.collectionName && (entry.referenceCollection || referenceIndex.size === 0)) continue
 
-			const resolved = await resolveCollectionText(trimmed)
-			if (!resolved) return
+			const source = lookupCollectionText(entry.text.trim(), referenceIndex)
+			if (!source) continue
 
-			const refMeta = resolved.referencedBy
-				? { referenceCollection: resolved.source.collectionName, referencedBy: resolved.referencedBy }
+			const referencedBy = source.collectionName ? referenceIndex.get(source.collectionName) : undefined
+			const refMeta = referencedBy
+				? { referenceCollection: source.collectionName, referencedBy }
 				: {}
 			enhanced[id] = {
 				...entry,
-				collectionName: entry.collectionName ?? resolved.source.collectionName,
-				collectionSlug: entry.collectionSlug ?? resolved.source.collectionSlug,
+				collectionName: entry.collectionName ?? source.collectionName,
+				collectionSlug: entry.collectionSlug ?? source.collectionSlug,
 				...refMeta,
 			}
-		})
-		await Promise.all(augmentPromises)
+		}
 	}
 
 	return enhanced

package/src/types.ts

@@ -567,10 +567,6 @@ export interface CmsEditorState {
 		seo: number
 		total: number
 	}
-	deployment: {
-		status: 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'cancelled' | null
-		lastDeployedAt: string | null
-	}
 	canUndo: boolean
 	canRedo: boolean
 }

package/src/utils.ts

@@ -190,6 +190,16 @@ export async function acquireFileLock(filePath: string): Promise<() => void> {
 
 export { slugify } from './shared'
 
+/**
+ * Return the first non-empty, trimmed line from a text block (e.g. markdown body).
+ */
+export function firstNonEmptyLine(text: string | undefined): string | undefined {
+	return text
+		?.split('\n')
+		.find((line) => line.trim().length > 0)
+		?.trim()
+}
+
 /**
  * Type-safe check for Node.js system errors (ENOENT, EEXIST, etc.).
  */

package/src/vite-plugin.ts

@@ -1,6 +1,7 @@
 import type { Plugin } from 'vite'
 import { expectedDeletions } from './dev-middleware'
 import type { ManifestWriter } from './manifest-writer'
+import { markFileDirty } from './source-finder'
 import type { CmsMarkerOptions, ComponentDefinition } from './types'
 import { createArrayTransformPlugin } from './vite-plugin-array-transform'
 
@@ -35,17 +36,36 @@ export function createVitePlugin(context: VitePluginContext): Plugin[] {
 		},
 	}
 
-	// Intercept Vite's file watcher to suppress full page reloads when the CMS
-	// deletes a content collection entry. Without this, Vite/Astro detects the
-	// unlink and forces a reload, undoing the optimistic UI update.
+	// File extensions that are indexed by the CMS search index
+	const INDEXED_EXTENSIONS = /\.(astro|tsx|jsx|json|ya?ml|mdx?)$/
+
+	// Stable handler reference so configureServer re-entry doesn't leak listeners
+	const onFileChange = (filePath: string) => {
+		if (INDEXED_EXTENSIONS.test(filePath)) {
+			markFileDirty(filePath)
+		}
+	}
+
+	// Intercept Vite's file watcher to:
+	// 1. Mark changed source files dirty for incremental re-indexing
+	// 2. Suppress full page reloads when the CMS deletes a content collection entry
 	const watcherPlugin: Plugin = {
 		name: 'cms-suppress-delete-reload',
 		configureServer(server) {
 			if (command !== 'dev') return
 
+			const watcher = server.watcher
+
+			// Mark changed files dirty so the search index re-indexes only them.
+			// Remove first to avoid duplicate listeners on Astro dev server restarts.
+			watcher.off('change', onFileChange).on('change', onFileChange)
+			watcher.off('add', onFileChange).on('add', onFileChange)
+			// Astro + Vite plugins collectively add many 'change' listeners to the
+			// shared watcher. Raise the limit to suppress the spurious warning.
+			watcher.setMaxListeners(20)
+
 			// Monkey-patch the watcher to intercept unlink events before Vite/Astro
 			// processes them. We use prependListener so our handler runs first.
-			const watcher = server.watcher
 			const origEmit = watcher.emit.bind(watcher)
 			watcher.emit = ((event: string, filePath: string, ...args: any[]) => {
 				if ((event === 'unlink' || event === 'unlinkDir') && expectedDeletions.has(filePath)) {