@nuasite/cms 0.1.0

package/src/source-finder/ast-extractors.ts

@@ -0,0 +1,185 @@
+import type { BabelNode, LineTransformer, VariableDefinition } from './types'
+
+// ============================================================================
+// String Value Extraction
+// ============================================================================
+
+/**
+ * Extract string value from a Babel node (StringLiteral or simple TemplateLiteral)
+ */
+export function getStringValue(node: BabelNode): string | null {
+	if (node.type === 'StringLiteral') {
+		return node.value as string
+	}
+	if (node.type === 'TemplateLiteral') {
+		const quasis = node.quasis as Array<{ value: { cooked: string | null } }> | undefined
+		const expressions = node.expressions as unknown[] | undefined
+		if (quasis?.length === 1 && expressions?.length === 0) {
+			return quasis[0]?.value.cooked ?? null
+		}
+	}
+	return null
+}
+
+// ============================================================================
+// Object and Array Extraction
+// ============================================================================
+
+/**
+ * Extract property name from an object key node.
+ * Handles both `{ name: value }` (Identifier) and `{ "name": value }` (StringLiteral).
+ */
+function getKeyName(key: BabelNode): string | null {
+	if (key.type === 'Identifier') return key.name as string
+	if (key.type === 'StringLiteral') return key.value as string
+	return null
+}
+
+/**
+ * Recursively extract properties from an object expression
+ * @param objNode - The ObjectExpression node
+ * @param parentPath - The full path to this object (e.g., 'config' or 'config.nav')
+ * @param definitions - Array to collect definitions into
+ * @param lineTransformer - Transforms Babel line numbers to file line numbers
+ */
+export function extractObjectProperties(
+	objNode: BabelNode,
+	parentPath: string,
+	definitions: VariableDefinition[],
+	lineTransformer: LineTransformer,
+): void {
+	const properties = objNode.properties as BabelNode[] | undefined
+	for (const prop of properties ?? []) {
+		if (prop.type !== 'ObjectProperty') continue
+		const key = prop.key as BabelNode | undefined
+		const value = prop.value as BabelNode | undefined
+		if (!key || !value) continue
+		const propName = getKeyName(key)
+		if (!propName) continue
+		const fullPath = `${parentPath}.${propName}`
+		const propLoc = prop.loc as { start: { line: number } } | undefined
+		const propLine = lineTransformer(propLoc?.start.line ?? 1)
+
+		const stringValue = getStringValue(value)
+		if (stringValue !== null) {
+			definitions.push({
+				name: propName,
+				value: stringValue,
+				line: propLine,
+				parentName: parentPath,
+			})
+		}
+
+		// Recurse for nested objects
+		if (value.type === 'ObjectExpression') {
+			extractObjectProperties(value, fullPath, definitions, lineTransformer)
+		}
+
+		// Handle arrays within objects
+		if (value.type === 'ArrayExpression') {
+			extractArrayElements(value, fullPath, definitions, lineTransformer, propLine)
+		}
+	}
+}
+
+/**
+ * Extract elements from an array expression
+ * @param arrNode - The ArrayExpression node
+ * @param parentPath - The full path to this array (e.g., 'items' or 'config.items')
+ * @param definitions - Array to collect definitions into
+ * @param lineTransformer - Transforms Babel line numbers to file line numbers
+ * @param defaultLine - Fallback line if element has no location
+ */
+export function extractArrayElements(
+	arrNode: BabelNode,
+	parentPath: string,
+	definitions: VariableDefinition[],
+	lineTransformer: LineTransformer,
+	defaultLine: number,
+): void {
+	const elements = arrNode.elements as BabelNode[] | undefined
+	for (let i = 0; i < (elements?.length ?? 0); i++) {
+		const elem = elements![i]
+		if (!elem) continue
+
+		const elemLoc = elem.loc as { start: { line: number } } | undefined
+		const elemLine = elemLoc ? lineTransformer(elemLoc.start.line) : defaultLine
+		const indexPath = `${parentPath}[${i}]`
+
+		// Handle string values in array
+		const elemValue = getStringValue(elem)
+		if (elemValue !== null) {
+			definitions.push({
+				name: String(i),
+				value: elemValue,
+				line: elemLine,
+				parentName: parentPath,
+			})
+		}
+
+		// Handle array of objects: [{ text: 'Home' }] or [{ "text": 'Home' }]
+		if (elem.type === 'ObjectExpression') {
+			const objProperties = elem.properties as BabelNode[] | undefined
+			for (const prop of objProperties ?? []) {
+				if (prop.type !== 'ObjectProperty') continue
+				const key = prop.key as BabelNode | undefined
+				const value = prop.value as BabelNode | undefined
+				if (!key || !value) continue
+				const propName = getKeyName(key)
+				if (!propName) continue
+				const propLoc = prop.loc as { start: { line: number } } | undefined
+				const propLine = propLoc ? lineTransformer(propLoc.start.line) : elemLine
+
+				const stringValue = getStringValue(value)
+				if (stringValue !== null) {
+					definitions.push({
+						name: propName,
+						value: stringValue,
+						line: propLine,
+						parentName: indexPath,
+					})
+				}
+
+				// Recurse for nested objects within array elements
+				if (value.type === 'ObjectExpression') {
+					extractObjectProperties(value, `${indexPath}.${propName}`, definitions, lineTransformer)
+				}
+			}
+		}
+	}
+}
+
+// ============================================================================
+// Path Building Utilities
+// ============================================================================
+
+/**
+ * Build the full path for a variable definition.
+ * For array indices (numeric names), uses bracket notation: items[0]
+ * For object properties, uses dot notation: config.nav.title
+ */
+export function buildDefinitionPath(def: VariableDefinition): string {
+	if (!def.parentName) {
+		return def.name
+	}
+	// Check if the name is a numeric index (for arrays)
+	if (/^\d+$/.test(def.name)) {
+		return `${def.parentName}[${def.name}]`
+	}
+	return `${def.parentName}.${def.name}`
+}
+
+/**
+ * Parse an expression path and extract the full path for variable lookup.
+ * Handles patterns like: varName, obj.prop, items[0], config.nav.title, links[0].text
+ * @returns The full expression path or null if not a simple variable reference
+ */
+export function parseExpressionPath(exprText: string): string | null {
+	// Match patterns like: varName, obj.prop, items[0], config.nav.title, links[0].text
+	// Pattern breakdown: word characters, dots, and bracket notation with numbers
+	const match = exprText.match(/^\s*([\w]+(?:\.[\w]+|\[\d+\])*(?:\.[\w]+)?)\s*$/)
+	if (match) {
+		return match[1]!
+	}
+	return null
+}

package/src/source-finder/ast-parser.ts

@@ -0,0 +1,150 @@
+import { parse as parseAstro } from '@astrojs/compiler'
+import type { Node as AstroNode } from '@astrojs/compiler/types'
+import { parse as parseBabel } from '@babel/parser'
+import fs from 'node:fs/promises'
+
+import { getErrorCollector } from '../error-collector'
+import { getParsedFileCache } from './cache'
+import type { BabelFile, CachedParsedFile, ParsedAstroFile } from './types'
+import { extractImports, extractPropAliases, extractVariableDefinitions } from './variable-extraction'
+
+// ============================================================================
+// Astro File Parsing
+// ============================================================================
+
+/**
+ * Parse an Astro file and return both template AST and frontmatter content
+ */
+export 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
+ */
+export function parseFrontmatter(content: string, filePath?: string): BabelFile | null {
+	try {
+		return parseBabel(content, {
+			sourceType: 'module',
+			plugins: ['typescript'],
+			errorRecovery: true,
+		}) as unknown as BabelFile
+	} catch (error) {
+		// Record parse errors for aggregated reporting
+		if (filePath) {
+			getErrorCollector().addWarning(
+				`Frontmatter parse: ${filePath}`,
+				error instanceof Error ? error.message : String(error),
+			)
+		}
+		return null
+	}
+}
+
+// ============================================================================
+// Cached File Access
+// ============================================================================
+
+/** Deduplicates concurrent parsing requests for the same file */
+const inFlightParsing = new Map<string, Promise<CachedParsedFile | null>>()
+
+/**
+ * Get a cached parsed file, parsing it if not cached.
+ * Concurrent requests for the same file are deduplicated to avoid
+ * redundant parsing and potential race conditions.
+ */
+export async function getCachedParsedFile(filePath: string): Promise<CachedParsedFile | null> {
+	const cache = getParsedFileCache()
+	const cached = cache.get(filePath)
+	if (cached) return cached
+
+	// Deduplicate concurrent requests for the same file
+	const inFlight = inFlightParsing.get(filePath)
+	if (inFlight) return inFlight
+
+	const promise = parseAndCacheFile(filePath, cache)
+	inFlightParsing.set(filePath, promise)
+
+	try {
+		return await promise
+	} finally {
+		inFlightParsing.delete(filePath)
+	}
+}
+
+async function parseAndCacheFile(
+	filePath: string,
+	cache: Map<string, CachedParsedFile>,
+): Promise<CachedParsedFile | null> {
+	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: [],
+				propAliases: new Map(),
+				imports: [],
+			}
+			cache.set(filePath, entry)
+			return entry
+		}
+
+		const { ast, frontmatterContent, frontmatterStartLine } = await parseAstroFile(content)
+
+		let variableDefinitions: CachedParsedFile['variableDefinitions'] = []
+		let propAliases: Map<string, string> = new Map()
+		let imports: CachedParsedFile['imports'] = []
+		if (frontmatterContent) {
+			const frontmatterAst = parseFrontmatter(frontmatterContent, filePath)
+			if (frontmatterAst) {
+				variableDefinitions = extractVariableDefinitions(frontmatterAst, frontmatterStartLine)
+				propAliases = extractPropAliases(frontmatterAst)
+				imports = extractImports(frontmatterAst)
+			}
+		}
+
+		const entry: CachedParsedFile = {
+			content,
+			lines,
+			ast,
+			frontmatterContent,
+			frontmatterStartLine,
+			variableDefinitions,
+			propAliases,
+			imports,
+		}
+
+		cache.set(filePath, entry)
+		return entry
+	} catch {
+		return null
+	}
+}

package/src/source-finder/cache.ts

@@ -0,0 +1,76 @@
+import type { CachedParsedFile, ImageIndexEntry, SearchIndexEntry } from './types'
+
+// ============================================================================
+// File Parsing Cache - Avoid re-parsing the same files
+// ============================================================================
+
+/** 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[] }>()
+
+/** Search indexes built once per build — use the same array instance and clear with length=0 to avoid stale references */
+const textSearchIndex: SearchIndexEntry[] = []
+const imageSearchIndex: ImageIndexEntry[] = []
+let searchIndexInitialized = false
+
+// ============================================================================
+// Cache Access Functions
+// ============================================================================
+
+export function getParsedFileCache(): Map<string, CachedParsedFile> {
+	return parsedFileCache
+}
+
+export function getDirectoryCache(): Map<string, string[]> {
+	return directoryCache
+}
+
+export function getMarkdownFileCache(): Map<string, { content: string; lines: string[] }> {
+	return markdownFileCache
+}
+
+export function getTextSearchIndex(): SearchIndexEntry[] {
+	return textSearchIndex
+}
+
+export function getImageSearchIndex(): ImageIndexEntry[] {
+	return imageSearchIndex
+}
+
+export function isSearchIndexInitialized(): boolean {
+	return searchIndexInitialized
+}
+
+export function setSearchIndexInitialized(value: boolean): void {
+	searchIndexInitialized = value
+}
+
+export function addToTextSearchIndex(entry: SearchIndexEntry): void {
+	textSearchIndex.push(entry)
+}
+
+export function addToImageSearchIndex(entry: ImageIndexEntry): void {
+	imageSearchIndex.push(entry)
+}
+
+// ============================================================================
+// Cache Clear Function
+// ============================================================================
+
+/**
+ * Clear all caches - call at start of each build
+ */
+export function clearSourceFinderCache(): void {
+	parsedFileCache.clear()
+	directoryCache.clear()
+	markdownFileCache.clear()
+	// Clear arrays in-place to avoid stale references from consumers
+	textSearchIndex.length = 0
+	imageSearchIndex.length = 0
+	searchIndexInitialized = false
+}