@nuasite/cms-marker 0.0.64 → 0.0.66

package/src/source-finder.ts

@@ -1,8 +1,444 @@
+import { parse as parseAstro } from '@astrojs/compiler'
+import type { ComponentNode, ElementNode, Node as AstroNode, TextNode } from '@astrojs/compiler/types'
+import { parse as parseBabel } from '@babel/parser'
+import type * as t from '@babel/types'
 import fs from 'node:fs/promises'
 import path from 'node:path'
+import { getProjectRoot } from './config'
+import { getErrorCollector } from './error-collector'
 import type { ManifestEntry } from './types'
 import { generateSourceHash } from './utils'
 
+// ============================================================================
+// File Parsing Cache - Avoid re-parsing the same files
+// ============================================================================
+
+interface CachedParsedFile {
+	content: string
+	lines: string[]
+	ast: AstroNode
+	frontmatterContent: string | null
+	frontmatterStartLine: number
+	variableDefinitions: VariableDefinition[]
+}
+
+/** Cache for parsed Astro files - cleared between builds */
+const parsedFileCache = new Map<string, CachedParsedFile>()
+
+/** Cache for directory listings - cleared between builds */
+const directoryCache = new Map<string, string[]>()
+
+/** Cache for markdown file contents - cleared between builds */
+const markdownFileCache = new Map<string, { content: string; lines: string[] }>()
+
+/** Pre-built search index for fast lookups */
+interface SearchIndexEntry {
+	file: string
+	line: number
+	snippet: string
+	type: 'static' | 'variable' | 'prop' | 'computed'
+	variableName?: string
+	definitionLine?: number
+	normalizedText: string
+	tag: string
+}
+
+interface ImageIndexEntry {
+	file: string
+	line: number
+	snippet: string
+	src: string
+}
+
+/** Search indexes built once per build */
+let textSearchIndex: SearchIndexEntry[] = []
+let imageSearchIndex: ImageIndexEntry[] = []
+let searchIndexInitialized = false
+
+/**
+ * Clear all caches - call at start of each build
+ */
+export function clearSourceFinderCache(): void {
+	parsedFileCache.clear()
+	directoryCache.clear()
+	markdownFileCache.clear()
+	textSearchIndex = []
+	imageSearchIndex = []
+	searchIndexInitialized = false
+}
+
+/**
+ * Initialize search index by pre-scanning all source files.
+ * This is much faster than searching per-entry.
+ */
+export async function initializeSearchIndex(): Promise<void> {
+	if (searchIndexInitialized) return
+
+	const srcDir = path.join(getProjectRoot(), 'src')
+	const searchDirs = [
+		path.join(srcDir, 'components'),
+		path.join(srcDir, 'pages'),
+		path.join(srcDir, 'layouts'),
+	]
+
+	// Collect all Astro files first
+	const allFiles: string[] = []
+	for (const dir of searchDirs) {
+		try {
+			const files = await collectAstroFiles(dir)
+			allFiles.push(...files)
+		} catch {
+			// Directory doesn't exist
+		}
+	}
+
+	// Parse all files in parallel and build indexes
+	await Promise.all(allFiles.map(async (filePath) => {
+		try {
+			const cached = await getCachedParsedFile(filePath)
+			if (!cached) return
+
+			const relFile = path.relative(getProjectRoot(), filePath)
+
+			// Index all text content from this file
+			indexFileContent(cached, relFile)
+
+			// Index all images from this file
+			indexFileImages(cached, relFile)
+		} catch {
+			// Skip files that fail to parse
+		}
+	}))
+
+	searchIndexInitialized = true
+}
+
+/**
+ * Collect all .astro files in a directory recursively
+ */
+async function collectAstroFiles(dir: string): Promise<string[]> {
+	const cached = directoryCache.get(dir)
+	if (cached) return cached
+
+	const results: string[] = []
+
+	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()) {
+				const subFiles = await collectAstroFiles(fullPath)
+				results.push(...subFiles)
+			} else if (entry.isFile() && (entry.name.endsWith('.astro') || entry.name.endsWith('.tsx') || entry.name.endsWith('.jsx'))) {
+				results.push(fullPath)
+			}
+		}))
+	} catch {
+		// Directory doesn't exist
+	}
+
+	directoryCache.set(dir, results)
+	return results
+}
+
+/**
+ * Get a cached parsed file, parsing it if not cached
+ */
+async function getCachedParsedFile(filePath: string): Promise<CachedParsedFile | null> {
+	const cached = parsedFileCache.get(filePath)
+	if (cached) return cached
+
+	try {
+		const content = await fs.readFile(filePath, 'utf-8')
+		const lines = content.split('\n')
+
+		// Only parse .astro files with AST
+		if (!filePath.endsWith('.astro')) {
+			// For tsx/jsx, just cache content/lines for regex search
+			const entry: CachedParsedFile = {
+				content,
+				lines,
+				ast: { type: 'root', children: [] } as unknown as AstroNode,
+				frontmatterContent: null,
+				frontmatterStartLine: 0,
+				variableDefinitions: [],
+			}
+			parsedFileCache.set(filePath, entry)
+			return entry
+		}
+
+		const { ast, frontmatterContent, frontmatterStartLine } = await parseAstroFile(content)
+
+		let variableDefinitions: VariableDefinition[] = []
+		if (frontmatterContent) {
+			const frontmatterAst = parseFrontmatter(frontmatterContent, filePath)
+			if (frontmatterAst) {
+				variableDefinitions = extractVariableDefinitions(frontmatterAst, frontmatterStartLine)
+			}
+		}
+
+		const entry: CachedParsedFile = {
+			content,
+			lines,
+			ast,
+			frontmatterContent,
+			frontmatterStartLine,
+			variableDefinitions,
+		}
+
+		parsedFileCache.set(filePath, entry)
+		return entry
+	} catch {
+		return null
+	}
+}
+
+/**
+ * Index all searchable text content from a parsed file
+ */
+function indexFileContent(cached: CachedParsedFile, relFile: string): void {
+	// Walk AST and collect all text elements
+	function visit(node: AstroNode) {
+		if ((node.type === 'element' || node.type === 'component')) {
+			const elemNode = node as ElementNode | ComponentNode
+			const tag = elemNode.name.toLowerCase()
+			const textContent = getTextContent(elemNode)
+			const normalizedText = normalizeText(textContent)
+			const line = elemNode.position?.start.line ?? 0
+
+			if (normalizedText && normalizedText.length >= 2) {
+				// Check for variable references
+				const exprInfo = hasExpressionChild(elemNode)
+				if (exprInfo.found && exprInfo.varNames.length > 0) {
+					for (const varName of exprInfo.varNames) {
+						for (const def of cached.variableDefinitions) {
+							if (def.name === varName || (def.parentName && def.name === varName)) {
+								const normalizedDef = normalizeText(def.value)
+								const completeSnippet = extractCompleteTagSnippet(cached.lines, line - 1, tag)
+								const snippet = extractInnerHtmlFromSnippet(completeSnippet, tag) ?? completeSnippet
+
+								textSearchIndex.push({
+									file: relFile,
+									line: def.line,
+									snippet: cached.lines[def.line - 1] || '',
+									type: 'variable',
+									variableName: def.parentName ? `${def.parentName}.${def.name}` : def.name,
+									definitionLine: def.line,
+									normalizedText: normalizedDef,
+									tag,
+								})
+							}
+						}
+					}
+				}
+
+				// Index static text content
+				const completeSnippet = extractCompleteTagSnippet(cached.lines, line - 1, tag)
+				const snippet = extractInnerHtmlFromSnippet(completeSnippet, tag) ?? completeSnippet
+
+				textSearchIndex.push({
+					file: relFile,
+					line,
+					snippet,
+					type: 'static',
+					normalizedText,
+					tag,
+				})
+			}
+
+			// Also index component props
+			if (node.type === 'component') {
+				for (const attr of elemNode.attributes) {
+					if (attr.type === 'attribute' && attr.kind === 'quoted' && attr.value) {
+						const normalizedValue = normalizeText(attr.value)
+						if (normalizedValue && normalizedValue.length >= 2) {
+							textSearchIndex.push({
+								file: relFile,
+								line: attr.position?.start.line ?? line,
+								snippet: cached.lines[(attr.position?.start.line ?? line) - 1] || '',
+								type: 'prop',
+								variableName: attr.name,
+								normalizedText: normalizedValue,
+								tag,
+							})
+						}
+					}
+				}
+			}
+		}
+
+		if ('children' in node && Array.isArray(node.children)) {
+			for (const child of node.children) {
+				visit(child)
+			}
+		}
+	}
+
+	visit(cached.ast)
+}
+
+/**
+ * Index all images from a parsed file
+ */
+function indexFileImages(cached: CachedParsedFile, relFile: string): void {
+	// For Astro files, use AST
+	if (relFile.endsWith('.astro')) {
+		function visit(node: AstroNode) {
+			if (node.type === 'element') {
+				const elemNode = node as ElementNode
+				if (elemNode.name.toLowerCase() === 'img') {
+					for (const attr of elemNode.attributes) {
+						if (attr.type === 'attribute' && attr.name === 'src' && attr.value) {
+							const srcLine = attr.position?.start.line ?? elemNode.position?.start.line ?? 0
+							const snippet = extractImageSnippet(cached.lines, srcLine - 1)
+							imageSearchIndex.push({
+								file: relFile,
+								line: srcLine,
+								snippet,
+								src: attr.value,
+							})
+						}
+					}
+				}
+			}
+
+			if ('children' in node && Array.isArray(node.children)) {
+				for (const child of node.children) {
+					visit(child)
+				}
+			}
+		}
+		visit(cached.ast)
+	} else {
+		// For tsx/jsx, use regex
+		const srcPatterns = [/src="([^"]+)"/g, /src='([^']+)'/g]
+		for (let i = 0; i < cached.lines.length; i++) {
+			const line = cached.lines[i]
+			if (!line) continue
+
+			for (const pattern of srcPatterns) {
+				pattern.lastIndex = 0
+				let match: RegExpExecArray | null
+				while ((match = pattern.exec(line)) !== null) {
+					const snippet = extractImageSnippet(cached.lines, i)
+					imageSearchIndex.push({
+						file: relFile,
+						line: i + 1,
+						snippet,
+						src: match[1]!,
+					})
+				}
+			}
+		}
+	}
+}
+
+/**
+ * Fast text lookup using pre-built index
+ */
+function findInTextIndex(textContent: string, tag: string): SourceLocation | undefined {
+	const normalizedSearch = normalizeText(textContent)
+	const tagLower = tag.toLowerCase()
+
+	// First try exact match with same tag
+	for (const entry of textSearchIndex) {
+		if (entry.tag === tagLower && entry.normalizedText === normalizedSearch) {
+			return {
+				file: entry.file,
+				line: entry.line,
+				snippet: entry.snippet,
+				type: entry.type,
+				variableName: entry.variableName,
+				definitionLine: entry.definitionLine,
+			}
+		}
+	}
+
+	// Then try partial match for longer text
+	if (normalizedSearch.length > 10) {
+		const textPreview = normalizedSearch.slice(0, Math.min(30, normalizedSearch.length))
+		for (const entry of textSearchIndex) {
+			if (entry.tag === tagLower && entry.normalizedText.includes(textPreview)) {
+				return {
+					file: entry.file,
+					line: entry.line,
+					snippet: entry.snippet,
+					type: entry.type,
+					variableName: entry.variableName,
+					definitionLine: entry.definitionLine,
+				}
+			}
+		}
+	}
+
+	// Try any tag match
+	for (const entry of textSearchIndex) {
+		if (entry.normalizedText === normalizedSearch) {
+			return {
+				file: entry.file,
+				line: entry.line,
+				snippet: entry.snippet,
+				type: entry.type,
+				variableName: entry.variableName,
+				definitionLine: entry.definitionLine,
+			}
+		}
+	}
+
+	return undefined
+}
+
+/**
+ * Fast image lookup using pre-built index
+ */
+function findInImageIndex(imageSrc: string): SourceLocation | undefined {
+	for (const entry of imageSearchIndex) {
+		if (entry.src === imageSrc) {
+			return {
+				file: entry.file,
+				line: entry.line,
+				snippet: entry.snippet,
+				type: 'static',
+			}
+		}
+	}
+	return undefined
+}
+
+// Helper for indexing - get text content from node
+function getTextContent(node: AstroNode): string {
+	if (node.type === 'text') {
+		return (node as TextNode).value
+	}
+	if ('children' in node && Array.isArray(node.children)) {
+		return node.children.map(getTextContent).join('')
+	}
+	return ''
+}
+
+// Helper for indexing - check for expression children
+function hasExpressionChild(node: AstroNode): { found: boolean; varNames: string[] } {
+	const varNames: string[] = []
+	if (node.type === 'expression') {
+		const exprText = getTextContent(node)
+		const match = exprText.match(/^\s*(\w+)(?:\.(\w+))?\s*$/)
+		if (match) {
+			varNames.push(match[2] ?? match[1]!)
+		}
+		return { found: true, varNames }
+	}
+	if ('children' in node && Array.isArray(node.children)) {
+		for (const child of node.children) {
+			const result = hasExpressionChild(child)
+			if (result.found) {
+				varNames.push(...result.varNames)
+			}
+		}
+	}
+	return { found: varNames.length > 0, varNames }
+}
+
 export interface SourceLocation {
 	file: string
 	line: number
@@ -43,14 +479,429 @@ export interface MarkdownContent {
 	collectionSlug: string
 }
 
+// ============================================================================
+// AST Parsing Utilities
+// ============================================================================
+
+interface ParsedAstroFile {
+	ast: AstroNode
+	frontmatterContent: string | null
+	frontmatterStartLine: number
+}
+
+/**
+ * Parse an Astro file and return both template AST and frontmatter content
+ */
+async function parseAstroFile(content: string): Promise<ParsedAstroFile> {
+	const result = await parseAstro(content, { position: true })
+
+	// Find frontmatter node
+	let frontmatterContent: string | null = null
+	let frontmatterStartLine = 0
+
+	for (const child of result.ast.children) {
+		if (child.type === 'frontmatter') {
+			frontmatterContent = child.value
+			frontmatterStartLine = child.position?.start.line ?? 1
+			break
+		}
+	}
+
+	return {
+		ast: result.ast,
+		frontmatterContent,
+		frontmatterStartLine,
+	}
+}
+
+/**
+ * Parse frontmatter JavaScript/TypeScript with Babel
+ * @param content - The frontmatter content to parse
+ * @param filePath - Optional file path for error reporting
+ */
+function parseFrontmatter(content: string, filePath?: string): t.File | null {
+	try {
+		return parseBabel(content, {
+			sourceType: 'module',
+			plugins: ['typescript'],
+			errorRecovery: true,
+		})
+	} catch (error) {
+		// Record parse errors for aggregated reporting
+		if (filePath) {
+			getErrorCollector().addWarning(
+				`Frontmatter parse: ${filePath}`,
+				error instanceof Error ? error.message : String(error),
+			)
+		}
+		return null
+	}
+}
+
+interface VariableDefinition {
+	name: string
+	value: string
+	line: number
+	/** For object properties, the parent variable name */
+	parentName?: string
+}
+
 /**
- * Find source file and line number for text content
+ * Extract variable definitions from Babel AST
+ * Finds const/let/var declarations with string literal values
+ *
+ * Note: Babel parses the frontmatter content (without --- delimiters) starting at line 1.
+ * frontmatterStartLine is the actual file line where the content begins (after first ---).
+ * So we convert: file_line = (babel_line - 1) + frontmatterStartLine
+ */
+function extractVariableDefinitions(ast: t.File, frontmatterStartLine: number): VariableDefinition[] {
+	const definitions: VariableDefinition[] = []
+
+	function getStringValue(node: t.Node): string | null {
+		if (node.type === 'StringLiteral') {
+			return node.value
+		}
+		if (node.type === 'TemplateLiteral' && node.quasis.length === 1 && node.expressions.length === 0) {
+			return node.quasis[0]?.value.cooked ?? null
+		}
+		return null
+	}
+
+	function babelLineToFileLine(babelLine: number): number {
+		// Babel's line 1 = frontmatterStartLine in the actual file
+		return (babelLine - 1) + frontmatterStartLine
+	}
+
+	function visitNode(node: t.Node) {
+		if (node.type === 'VariableDeclaration') {
+			for (const decl of node.declarations) {
+				if (decl.id.type === 'Identifier' && decl.init) {
+					const varName = decl.id.name
+					const line = babelLineToFileLine(decl.loc?.start.line ?? 1)
+
+					// Simple string value
+					const stringValue = getStringValue(decl.init)
+					if (stringValue !== null) {
+						definitions.push({ name: varName, value: stringValue, line })
+					}
+
+					// Object expression - extract properties
+					if (decl.init.type === 'ObjectExpression') {
+						for (const prop of decl.init.properties) {
+							if (prop.type === 'ObjectProperty' && prop.key.type === 'Identifier' && prop.value) {
+								const propValue = getStringValue(prop.value)
+								if (propValue !== null) {
+									const propLine = babelLineToFileLine(prop.loc?.start.line ?? 1)
+									definitions.push({
+										name: prop.key.name,
+										value: propValue,
+										line: propLine,
+										parentName: varName,
+									})
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+
+		// Recursively visit child nodes
+		for (const key of Object.keys(node)) {
+			const value = (node as unknown as Record<string, unknown>)[key]
+			if (value && typeof value === 'object') {
+				if (Array.isArray(value)) {
+					for (const item of value) {
+						if (item && typeof item === 'object' && 'type' in item) {
+							visitNode(item as t.Node)
+						}
+					}
+				} else if ('type' in value) {
+					visitNode(value as t.Node)
+				}
+			}
+		}
+	}
+
+	visitNode(ast.program)
+	return definitions
+}
+
+interface TemplateMatch {
+	line: number
+	type: 'static' | 'variable' | 'computed'
+	variableName?: string
+	/** For variables, the definition line in frontmatter */
+	definitionLine?: number
+}
+
+/**
+ * Walk the Astro AST to find elements matching a tag with specific text content
+ */
+function findElementWithText(
+	ast: AstroNode,
+	tag: string,
+	searchText: string,
+	variableDefinitions: VariableDefinition[],
+): TemplateMatch | null {
+	const normalizedSearch = normalizeText(searchText)
+	const tagLower = tag.toLowerCase()
+	let bestMatch: TemplateMatch | null = null
+	let bestScore = 0
+
+	function getTextContent(node: AstroNode): string {
+		if (node.type === 'text') {
+			return (node as TextNode).value
+		}
+		if ('children' in node && Array.isArray(node.children)) {
+			return node.children.map(getTextContent).join('')
+		}
+		return ''
+	}
+
+	function hasExpressionChild(node: AstroNode): { found: boolean; varNames: string[] } {
+		const varNames: string[] = []
+		if (node.type === 'expression') {
+			// Try to extract variable name from expression
+			// The expression node children contain the text representation
+			const exprText = getTextContent(node)
+			// Extract variable names like {foo} or {foo.bar}
+			const match = exprText.match(/^\s*(\w+)(?:\.(\w+))?\s*$/)
+			if (match) {
+				varNames.push(match[2] ?? match[1]!)
+			}
+			return { found: true, varNames }
+		}
+		if ('children' in node && Array.isArray(node.children)) {
+			for (const child of node.children) {
+				const result = hasExpressionChild(child)
+				if (result.found) {
+					varNames.push(...result.varNames)
+				}
+			}
+		}
+		return { found: varNames.length > 0, varNames }
+	}
+
+	function visit(node: AstroNode) {
+		// Check if this is an element or component matching our tag
+		if ((node.type === 'element' || node.type === 'component') && node.name.toLowerCase() === tagLower) {
+			const elemNode = node as ElementNode | ComponentNode
+			const textContent = getTextContent(elemNode)
+			const normalizedContent = normalizeText(textContent)
+			const line = elemNode.position?.start.line ?? 0
+
+			// Check for expression (variable reference)
+			const exprInfo = hasExpressionChild(elemNode)
+			if (exprInfo.found && exprInfo.varNames.length > 0) {
+				// Look for matching variable definition
+				for (const varName of exprInfo.varNames) {
+					for (const def of variableDefinitions) {
+						if (def.name === varName || (def.parentName && def.name === varName)) {
+							const normalizedDef = normalizeText(def.value)
+							if (normalizedDef === normalizedSearch) {
+								// Found a variable match - this is highest priority
+								if (bestScore < 100) {
+									bestScore = 100
+									bestMatch = {
+										line,
+										type: 'variable',
+										variableName: def.parentName ? `${def.parentName}.${def.name}` : def.name,
+										definitionLine: def.line,
+									}
+								}
+								return
+							}
+						}
+					}
+				}
+			}
+
+			// Check for direct text match (static content)
+			// Only match if there's meaningful text content (not just variable names/expressions)
+			if (normalizedContent && normalizedContent.length >= 2 && normalizedSearch.length > 0) {
+				// For short search text (<= 10 chars), require exact match
+				if (normalizedSearch.length <= 10) {
+					if (normalizedContent.includes(normalizedSearch)) {
+						const score = 80
+						if (score > bestScore) {
+							bestScore = score
+							const actualLine = findTextLine(elemNode, normalizedSearch)
+							bestMatch = {
+								line: actualLine ?? line,
+								type: 'static',
+							}
+						}
+					}
+				} // For longer search text, check if content contains a significant portion
+				else if (normalizedSearch.length > 10) {
+					const textPreview = normalizedSearch.slice(0, Math.min(30, normalizedSearch.length))
+					if (normalizedContent.includes(textPreview)) {
+						const matchLength = Math.min(normalizedSearch.length, normalizedContent.length)
+						const score = 50 + (matchLength / normalizedSearch.length) * 40
+						if (score > bestScore) {
+							bestScore = score
+							const actualLine = findTextLine(elemNode, textPreview)
+							bestMatch = {
+								line: actualLine ?? line,
+								type: 'static',
+							}
+						}
+					} // Try matching first few words for very long text
+					else if (normalizedSearch.length > 20) {
+						const firstWords = normalizedSearch.split(' ').slice(0, 3).join(' ')
+						if (firstWords && normalizedContent.includes(firstWords)) {
+							const score = 40
+							if (score > bestScore) {
+								bestScore = score
+								const actualLine = findTextLine(elemNode, firstWords)
+								bestMatch = {
+									line: actualLine ?? line,
+									type: 'static',
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+
+		// Recursively visit children
+		if ('children' in node && Array.isArray(node.children)) {
+			for (const child of node.children) {
+				visit(child)
+			}
+		}
+	}
+
+	function findTextLine(node: AstroNode, searchText: string): number | null {
+		if (node.type === 'text') {
+			const textNode = node as TextNode
+			if (normalizeText(textNode.value).includes(searchText)) {
+				return textNode.position?.start.line ?? null
+			}
+		}
+		if ('children' in node && Array.isArray(node.children)) {
+			for (const child of node.children) {
+				const line = findTextLine(child, searchText)
+				if (line !== null) return line
+			}
+		}
+		return null
+	}
+
+	visit(ast)
+	return bestMatch
+}
+
+interface ComponentPropMatch {
+	line: number
+	propName: string
+	propValue: string
+}
+
+/**
+ * Walk the Astro AST to find component props with specific text value
+ */
+function findComponentProp(
+	ast: AstroNode,
+	searchText: string,
+): ComponentPropMatch | null {
+	const normalizedSearch = normalizeText(searchText)
+
+	function visit(node: AstroNode): ComponentPropMatch | null {
+		// Check component nodes (PascalCase names)
+		if (node.type === 'component') {
+			const compNode = node as ComponentNode
+			for (const attr of compNode.attributes) {
+				if (attr.type === 'attribute' && attr.kind === 'quoted') {
+					const normalizedValue = normalizeText(attr.value)
+					if (normalizedValue === normalizedSearch) {
+						return {
+							line: attr.position?.start.line ?? compNode.position?.start.line ?? 0,
+							propName: attr.name,
+							propValue: attr.value,
+						}
+					}
+				}
+			}
+		}
+
+		// Recursively visit children
+		if ('children' in node && Array.isArray(node.children)) {
+			for (const child of node.children) {
+				const result = visit(child)
+				if (result) return result
+			}
+		}
+
+		return null
+	}
+
+	return visit(ast)
+}
+
+interface ImageMatch {
+	line: number
+	src: string
+	snippet: string
+}
+
+/**
+ * Walk the Astro AST to find img elements with specific src
+ */
+function findImageElement(
+	ast: AstroNode,
+	imageSrc: string,
+	lines: string[],
+): ImageMatch | null {
+	function visit(node: AstroNode): ImageMatch | null {
+		if (node.type === 'element') {
+			const elemNode = node as ElementNode
+			if (elemNode.name.toLowerCase() === 'img') {
+				for (const attr of elemNode.attributes) {
+					if (attr.type === 'attribute' && attr.name === 'src' && attr.value === imageSrc) {
+						const srcLine = attr.position?.start.line ?? elemNode.position?.start.line ?? 0
+						const snippet = extractImageSnippet(lines, srcLine - 1)
+						return {
+							line: srcLine,
+							src: imageSrc,
+							snippet,
+						}
+					}
+				}
+			}
+		}
+
+		// Recursively visit children
+		if ('children' in node && Array.isArray(node.children)) {
+			for (const child of node.children) {
+				const result = visit(child)
+				if (result) return result
+			}
+		}
+
+		return null
+	}
+
+	return visit(ast)
+}
+
+/**
+ * Find source file and line number for text content.
+ * Uses pre-built search index for fast lookups.
  */
 export async function findSourceLocation(
 	textContent: string,
 	tag: string,
 ): Promise<SourceLocation | undefined> {
-	const srcDir = path.join(process.cwd(), 'src')
+	// Use index if available (much faster)
+	if (searchIndexInitialized) {
+		return findInTextIndex(textContent, tag)
+	}
+
+	// Fallback to slow search if index not initialized
+	const srcDir = path.join(getProjectRoot(), 'src')
 
 	try {
 		const searchDirs = [
@@ -89,12 +940,19 @@ export async function findSourceLocation(
 }
 
 /**
- * Find source file and line number for an image by its src attribute
+ * Find source file and line number for an image by its src attribute.
+ * Uses pre-built search index for fast lookups.
  */
 export async function findImageSourceLocation(
 	imageSrc: string,
 ): Promise<SourceLocation | undefined> {
-	const srcDir = path.join(process.cwd(), 'src')
+	// Use index if available (much faster)
+	if (searchIndexInitialized) {
+		return findInImageIndex(imageSrc)
+	}
+
+	// Fallback to slow search if index not initialized
+	const srcDir = path.join(getProjectRoot(), 'src')
 
 	try {
 		const searchDirs = [
@@ -149,17 +1007,35 @@ async function searchDirectoryForImage(
 }
 
 /**
- * Search a single file for an image with matching src
+ * Search a single file for an image with matching src.
+ * Uses caching for better performance.
  */
 async function searchFileForImage(
 	filePath: string,
 	imageSrc: string,
 ): Promise<SourceLocation | undefined> {
 	try {
-		const content = await fs.readFile(filePath, 'utf-8')
-		const lines = content.split('\n')
+		// Use cached parsed file
+		const cached = await getCachedParsedFile(filePath)
+		if (!cached) return undefined
+
+		const { lines, ast } = cached
+
+		// Use AST parsing for Astro files
+		if (filePath.endsWith('.astro')) {
+			const imageMatch = findImageElement(ast, imageSrc, lines)
+
+			if (imageMatch) {
+				return {
+					file: path.relative(getProjectRoot(), filePath),
+					line: imageMatch.line,
+					snippet: imageMatch.snippet,
+					type: 'static',
+				}
+			}
+		}
 
-		// Search for src="imageSrc" or src='imageSrc'
+		// Regex fallback for TSX/JSX files or if AST parsing failed
 		const srcPatterns = [
 			`src="${imageSrc}"`,
 			`src='${imageSrc}'`,
@@ -175,7 +1051,7 @@ async function searchFileForImage(
 					const snippet = extractImageSnippet(lines, i)
 
 					return {
-						file: path.relative(process.cwd(), filePath),
+						file: path.relative(getProjectRoot(), filePath),
 						line: i + 1,
 						snippet,
 						type: 'static',
@@ -248,7 +1124,8 @@ async function searchDirectory(
 }
 
 /**
- * Search a single Astro file for matching content
+ * Search a single Astro file for matching content using AST parsing.
+ * Uses caching for better performance.
  */
 async function searchAstroFile(
 	filePath: string,
@@ -256,106 +1133,25 @@ async function searchAstroFile(
 	tag: string,
 ): Promise<SourceLocation | undefined> {
 	try {
-		const content = await fs.readFile(filePath, 'utf-8')
-		const lines = content.split('\n')
-
-		const cleanText = normalizeText(textContent)
-		const textPreview = cleanText.slice(0, Math.min(30, cleanText.length))
-
-		// Extract variable references from frontmatter
-		const variableRefs = extractVariableReferences(content, cleanText)
-
-		// Collect all potential matches with scores and metadata
-		const matches: Array<{
-			line: number
-			score: number
-			type: 'static' | 'variable' | 'prop' | 'computed'
-			variableName?: string
-			definitionLine?: number
-		}> = []
-
-		// Search for tag usage with matching text or variable
-		for (let i = 0; i < lines.length; i++) {
-			const line = lines[i]?.trim().toLowerCase()
-
-			// Look for opening tag
-			if (line?.includes(`<${tag.toLowerCase()}`) && !line.startsWith(`</${tag.toLowerCase()}`)) {
-				// Collect content from this line and next few lines
-				const section = collectSection(lines, i, 5)
-				const sectionText = section.toLowerCase()
-				const sectionTextOnly = stripHtmlTags(section).toLowerCase()
-
-				let score = 0
-				let matched = false
-
-				// Check for variable reference match (highest priority)
-				if (variableRefs.length > 0) {
-					for (const varRef of variableRefs) {
-						// Check case-insensitively since sectionText is lowercased
-						if (sectionText.includes(`{`) && sectionText.includes(varRef.name.toLowerCase())) {
-							score = 100
-							matched = true
-							// Store match metadata - this is the USAGE line, we need DEFINITION line
-							matches.push({
-								line: i + 1,
-								score,
-								type: 'variable',
-								variableName: varRef.name,
-								definitionLine: varRef.definitionLine,
-							})
-							break
-						}
-					}
-				}
-
-				// Check for direct text match (static content)
-				if (!matched && cleanText.length > 10 && sectionTextOnly.includes(textPreview)) {
-					// Score based on how much of the text matches
-					const matchLength = Math.min(cleanText.length, sectionTextOnly.length)
-					score = 50 + (matchLength / cleanText.length) * 40
-					matched = true
-					// Find the actual line containing the text
-					const actualLine = findLineContainingText(lines, i, 5, textPreview)
-					matches.push({ line: actualLine, score, type: 'static' })
-				}
+		// Use cached parsed file
+		const cached = await getCachedParsedFile(filePath)
+		if (!cached) return undefined
 
-				// Check for short exact text match (static content)
-				if (!matched && cleanText.length > 0 && cleanText.length <= 10 && sectionTextOnly.includes(cleanText)) {
-					score = 80
-					matched = true
-					// Find the actual line containing the text
-					const actualLine = findLineContainingText(lines, i, 5, cleanText)
-					matches.push({ line: actualLine, score, type: 'static' })
-				}
+		const { lines, ast, variableDefinitions } = cached
 
-				// Try matching first few words for longer text (static content)
-				if (!matched && cleanText.length > 20) {
-					const firstWords = cleanText.split(' ').slice(0, 3).join(' ')
-					if (firstWords && sectionTextOnly.includes(firstWords)) {
-						score = 40
-						matched = true
-						// Find the actual line containing the text
-						const actualLine = findLineContainingText(lines, i, 5, firstWords)
-						matches.push({ line: actualLine, score, type: 'static' })
-					}
-				}
-			}
-		}
-
-		// Return the best match (highest score)
-		if (matches.length > 0) {
-			const bestMatch = matches.reduce((best, current) => current.score > best.score ? current : best)
+		// Find matching element in template AST
+		const match = findElementWithText(ast, tag, textContent, variableDefinitions)
 
+		if (match) {
 			// Determine the editable line (definition for variables, usage for static)
-			const editableLine = bestMatch.type === 'variable' && bestMatch.definitionLine
-				? bestMatch.definitionLine
-				: bestMatch.line
+			const editableLine = match.type === 'variable' && match.definitionLine
+				? match.definitionLine
+				: match.line
 
 			// Get the source snippet - innerHTML for static content, definition line for variables
 			let snippet: string
-			if (bestMatch.type === 'static') {
+			if (match.type === 'static') {
 				// For static content, extract only the innerHTML (not the wrapper element)
-				// This ensures that when replacing, we only replace the content, not the element structure
 				const completeSnippet = extractCompleteTagSnippet(lines, editableLine - 1, tag)
 				snippet = extractInnerHtmlFromSnippet(completeSnippet, tag) ?? completeSnippet
 			} else {
@@ -364,27 +1160,27 @@ async function searchAstroFile(
 			}
 
 			return {
-				file: path.relative(process.cwd(), filePath),
+				file: path.relative(getProjectRoot(), filePath),
 				line: editableLine,
 				snippet,
-				type: bestMatch.type,
-				variableName: bestMatch.variableName,
-				definitionLine: bestMatch.type === 'variable' ? bestMatch.definitionLine : undefined,
+				type: match.type,
+				variableName: match.variableName,
+				definitionLine: match.type === 'variable' ? match.definitionLine : undefined,
 			}
 		}
 	} catch {
-		// Error reading file
+		// Error reading/parsing file
 	}
 
 	return undefined
 }
 
 /**
- * Search for prop values passed to components
+ * Search for prop values passed to components using AST parsing.
+ * Uses caching for better performance.
  */
 async function searchForPropInParents(dir: string, textContent: string): Promise<SourceLocation | undefined> {
 	const entries = await fs.readdir(dir, { withFileTypes: true })
-	const cleanText = normalizeText(textContent)
 
 	for (const entry of entries) {
 		const fullPath = path.join(dir, entry.name)
@@ -393,90 +1189,52 @@ async function searchForPropInParents(dir: string, textContent: string): Promise
 			const result = await searchForPropInParents(fullPath, textContent)
 			if (result) return result
 		} else if (entry.isFile() && entry.name.endsWith('.astro')) {
-			const content = await fs.readFile(fullPath, 'utf-8')
-			const lines = content.split('\n')
-
-			// Look for component tags with prop values matching our text
-			for (let i = 0; i < lines.length; i++) {
-				const line = lines[i]
-
-				// Match component usage like <ComponentName propName="value" />
-				const componentMatch = line?.match(/<([A-Z]\w+)/)
-				if (!componentMatch) continue
-
-				// Collect only the opening tag (until first > or />), not nested content
-				let openingTag = ''
-				let endLine = i
-				for (let j = i; j < Math.min(i + 10, lines.length); j++) {
-					openingTag += ' ' + lines[j]
-					endLine = j
-
-					// Stop at the end of opening tag (either /> or >)
-					if (lines[j]?.includes('/>')) {
-						// Self-closing tag
-						break
-					} else if (lines[j]?.includes('>')) {
-						// Opening tag ends here, don't include nested content
-						// Truncate to just the opening tag part
-						const tagEndIndex = openingTag.indexOf('>')
-						if (tagEndIndex !== -1) {
-							openingTag = openingTag.substring(0, tagEndIndex + 1)
-						}
-						break
-					}
-				}
-
-				// Extract all prop values from the opening tag only
-				const propMatches = openingTag.matchAll(/(\w+)=["']([^"']+)["']/g)
-				for (const match of propMatches) {
-					const propName = match[1]
-					const propValue = match[2]
+			try {
+				// Use cached parsed file
+				const cached = await getCachedParsedFile(fullPath)
+				if (!cached) continue
 
-					if (!propValue) {
-						continue
-					}
+				const { lines, ast } = cached
 
-					const normalizedValue = normalizeText(propValue)
+				// Find component props matching our text
+				const propMatch = findComponentProp(ast, textContent)
 
-					if (normalizedValue === cleanText) {
-						// Find which line actually contains this prop
-						let propLine = i
+				if (propMatch) {
+					// Extract component snippet for context
+					const componentStart = propMatch.line - 1
+					const snippetLines: string[] = []
+					let depth = 0
 
-						for (let k = i; k <= endLine; k++) {
-							const line = lines[k]
-							if (!line) {
-								continue
-							}
+					for (let i = componentStart; i < Math.min(componentStart + 10, lines.length); i++) {
+						const line = lines[i]
+						if (!line) continue
+						snippetLines.push(line)
 
-							if (propName && line.includes(propName) && line.includes(propValue)) {
-								propLine = k
-								break
-							}
+						// Check for self-closing or end of opening tag
+						if (line.includes('/>')) {
+							break
 						}
-
-						// Extract complete component tag starting from where the component tag opens
-						const componentSnippetLines: string[] = []
-						for (let k = i; k <= endLine; k++) {
-							const line = lines[k]
-							if (!line) {
-								continue
+						if (line.includes('>') && !line.includes('/>')) {
+							// Count opening tags
+							const opens = (line.match(/<[A-Z]/g) || []).length
+							const closes = (line.match(/\/>/g) || []).length
+							depth += opens - closes
+							if (depth <= 0 || (i > componentStart && line.includes('>'))) {
+								break
 							}
-
-							componentSnippetLines.push(line)
 						}
+					}
 
-						const propSnippet = componentSnippetLines.join('\n')
-
-						// Found the prop being passed with our text value
-						return {
-							file: path.relative(process.cwd(), fullPath),
-							line: propLine + 1,
-							snippet: propSnippet,
-							type: 'prop',
-							variableName: propName,
-						}
+					return {
+						file: path.relative(getProjectRoot(), fullPath),
+						line: propMatch.line,
+						snippet: snippetLines.join('\n'),
+						type: 'prop',
+						variableName: propMatch.propName,
 					}
 				}
+			} catch {
+				// Error parsing file, continue
 			}
 		}
 	}
@@ -487,14 +1245,38 @@ async function searchForPropInParents(dir: string, textContent: string): Promise
 /**
  * Extract complete tag snippet including content and indentation.
  * Exported for use in html-processor to populate sourceSnippet.
+ *
+ * When startLine points to a line inside the element (e.g., the text content line),
+ * this function searches backwards to find the opening tag first.
  */
 export function extractCompleteTagSnippet(lines: string[], startLine: number, tag: string): string {
+	// Pattern to match opening tag - either followed by whitespace/>, or at end of line (multi-line tag)
+	const openTagPattern = new RegExp(`<${tag}(?:[\\s>]|$)`, 'gi')
+
+	// Check if the start line contains the opening tag
+	let actualStartLine = startLine
+	const startLineContent = lines[startLine] || ''
+	if (!openTagPattern.test(startLineContent)) {
+		// Search backwards to find the opening tag
+		for (let i = startLine - 1; i >= Math.max(0, startLine - 20); i--) {
+			const line = lines[i]
+			if (!line) continue
+
+			// Reset regex lastIndex for fresh test
+			openTagPattern.lastIndex = 0
+			if (openTagPattern.test(line)) {
+				actualStartLine = i
+				break
+			}
+		}
+	}
+
 	const snippetLines: string[] = []
 	let depth = 0
 	let foundClosing = false
 
 	// Start from the opening tag line
-	for (let i = startLine; i < Math.min(startLine + 20, lines.length); i++) {
+	for (let i = actualStartLine; i < Math.min(actualStartLine + 30, lines.length); i++) {
 		const line = lines[i]
 
 		if (!line) {
@@ -504,7 +1286,8 @@ export function extractCompleteTagSnippet(lines: string[], startLine: number, ta
 		snippetLines.push(line)
 
 		// Count opening and closing tags
-		const openTags = (line.match(new RegExp(`<${tag}[\\s>]`, 'gi')) || []).length
+		// Opening tag can be followed by whitespace, >, or end of line (multi-line tag)
+		const openTags = (line.match(new RegExp(`<${tag}(?:[\\s>]|$)`, 'gi')) || []).length
 		const selfClosing = (line.match(new RegExp(`<${tag}[^>]*/>`, 'gi')) || []).length
 		const closeTags = (line.match(new RegExp(`</${tag}>`, 'gi')) || []).length
 
@@ -572,7 +1355,7 @@ export async function extractSourceInnerHtml(
 	try {
 		const filePath = path.isAbsolute(sourceFile)
 			? sourceFile
-			: path.join(process.cwd(), sourceFile)
+			: path.join(getProjectRoot(), sourceFile)
 
 		const content = await fs.readFile(filePath, 'utf-8')
 		const lines = content.split('\n')
@@ -587,104 +1370,6 @@ export async function extractSourceInnerHtml(
 	}
 }
 
-/**
- * Extract variable references from frontmatter
- */
-function extractVariableReferences(content: string, targetText: string): VariableReference[] {
-	const refs: VariableReference[] = []
-	const frontmatterEnd = content.indexOf('---', 3)
-
-	if (frontmatterEnd <= 0) return refs
-
-	const frontmatter = content.substring(0, frontmatterEnd)
-	const lines = frontmatter.split('\n')
-
-	for (const line of lines) {
-		const trimmed = line.trim()
-
-		// Match quoted text (handling escaped quotes)
-		// Try single quotes with escaped quotes
-		let quotedMatch = trimmed.match(/'((?:[^'\\]|\\.)*)'/)
-		if (!quotedMatch) {
-			// Try double quotes with escaped quotes
-			quotedMatch = trimmed.match(/"((?:[^"\\]|\\.)*)"/)
-		}
-		if (!quotedMatch) {
-			// Try backticks (template literals) - but only if no ${} interpolation
-			const backtickMatch = trimmed.match(/`([^`]*)`/)
-			if (backtickMatch && !backtickMatch[1]?.includes('${')) {
-				quotedMatch = backtickMatch
-			}
-		}
-		if (!quotedMatch?.[1]) continue
-
-		const value = normalizeText(quotedMatch[1])
-		const normalizedTarget = normalizeText(targetText)
-
-		if (value !== normalizedTarget) continue
-
-		// Try to extract variable name and line number
-		const lineNumber = lines.indexOf(line) + 1
-
-		// Pattern 1: Object property "key: 'value'"
-		const propMatch = trimmed.match(/(\w+)\s*:\s*['"`]/)
-		if (propMatch?.[1]) {
-			refs.push({
-				name: propMatch[1],
-				pattern: `{.*${propMatch[1]}`,
-				definitionLine: lineNumber,
-			})
-			continue
-		}
-
-		// Pattern 2: Variable declaration "const name = 'value'"
-		const varMatch = trimmed.match(/(?:const|let|var)\s+(\w+)(?:\s*:\s*\w+)?\s*=/)
-		if (varMatch?.[1]) {
-			refs.push({
-				name: varMatch[1],
-				pattern: `{${varMatch[1]}}`,
-				definitionLine: lineNumber,
-			})
-		}
-	}
-
-	return refs
-}
-
-/**
- * Collect text from multiple lines
- */
-function collectSection(lines: string[], startLine: number, numLines: number): string {
-	let text = ''
-	for (let i = startLine; i < Math.min(startLine + numLines, lines.length); i++) {
-		text += ' ' + lines[i]?.trim().replace(/\s+/g, ' ')
-	}
-	return text
-}
-
-/**
- * Find the actual line containing the matched text within a section
- * Returns 1-indexed line number
- */
-function findLineContainingText(lines: string[], startLine: number, numLines: number, searchText: string): number {
-	const normalizedSearch = searchText.toLowerCase()
-	for (let i = startLine; i < Math.min(startLine + numLines, lines.length); i++) {
-		const lineText = stripHtmlTags(lines[i] || '').toLowerCase()
-		if (lineText.includes(normalizedSearch)) {
-			return i + 1 // Return 1-indexed line number
-		}
-	}
-	// If not found on a specific line, return the opening tag line
-	return startLine + 1
-}
-
-/**
- * Strip HTML tags from text
- */
-function stripHtmlTags(text: string): string {
-	return text.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim()
-}
-
 /**
  * Normalize text for comparison (handles escaping and entities)
  */
@@ -720,7 +1405,7 @@ export async function findCollectionSource(
 		return undefined
 	}
 
-	const contentPath = path.join(process.cwd(), contentDir)
+	const contentPath = path.join(getProjectRoot(), contentDir)
 
 	try {
 		// Check if content directory exists
@@ -757,7 +1442,7 @@ export async function findCollectionSource(
 		return {
 			name: collectionName,
 			slug,
-			file: path.relative(process.cwd(), mdFile),
+			file: path.relative(getProjectRoot(), mdFile),
 		}
 	}
 
@@ -820,6 +1505,24 @@ async function findMarkdownFile(collectionPath: string, slug: string): Promise<s
 	return undefined
 }
 
+/**
+ * Get cached markdown file content
+ */
+async function getCachedMarkdownFile(filePath: string): Promise<{ content: string; lines: string[] } | null> {
+	const cached = markdownFileCache.get(filePath)
+	if (cached) return cached
+
+	try {
+		const content = await fs.readFile(filePath, 'utf-8')
+		const lines = content.split('\n')
+		const entry = { content, lines }
+		markdownFileCache.set(filePath, entry)
+		return entry
+	} catch {
+		return null
+	}
+}
+
 /**
  * Find text content in a markdown file and return source location
  * Only matches frontmatter fields, not body content (body is handled separately as a whole)
@@ -832,9 +1535,11 @@ export async function findMarkdownSourceLocation(
 	collectionInfo: CollectionInfo,
 ): Promise<SourceLocation | undefined> {
 	try {
-		const filePath = path.join(process.cwd(), collectionInfo.file)
-		const content = await fs.readFile(filePath, 'utf-8')
-		const lines = content.split('\n')
+		const filePath = path.join(getProjectRoot(), collectionInfo.file)
+		const cached = await getCachedMarkdownFile(filePath)
+		if (!cached) return undefined
+
+		const { lines } = cached
 		const normalizedSearch = normalizeText(textContent)
 
 		// Parse frontmatter
@@ -898,7 +1603,8 @@ export async function findMarkdownSourceLocation(
 }
 
 /**
- * Parse markdown file and extract frontmatter fields and full body content
+ * Parse markdown file and extract frontmatter fields and full body content.
+ * Uses caching for better performance.
  * @param collectionInfo - Collection information (name, slug, file path)
  * @returns Parsed markdown content with frontmatter and body
  */
@@ -906,9 +1612,11 @@ export async function parseMarkdownContent(
 	collectionInfo: CollectionInfo,
 ): Promise<MarkdownContent | undefined> {
 	try {
-		const filePath = path.join(process.cwd(), collectionInfo.file)
-		const content = await fs.readFile(filePath, 'utf-8')
-		const lines = content.split('\n')
+		const filePath = path.join(getProjectRoot(), collectionInfo.file)
+		const cached = await getCachedMarkdownFile(filePath)
+		if (!cached) return undefined
+
+		const { lines } = cached
 
 		// Parse frontmatter
 		let frontmatterStart = -1
@@ -1008,10 +1716,10 @@ export async function enhanceManifestWithSourceSnippets(
 	// 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
-		if (entry.sourceType === 'image' && entry.imageSrc) {
-			const imageLocation = await findImageSourceLocation(entry.imageSrc)
+		if (entry.sourceType === 'image' && entry.imageMetadata?.src) {
+			const imageLocation = await findImageSourceLocation(entry.imageMetadata.src)
 			if (imageLocation) {
-				const sourceHash = generateSourceHash(imageLocation.snippet || entry.imageSrc)
+				const sourceHash = generateSourceHash(imageLocation.snippet || entry.imageMetadata.src)
 				return [id, {
 					...entry,
 					sourcePath: imageLocation.file,