@nuasite/cms 0.1.0

package/src/collection-scanner.ts

@@ -0,0 +1,304 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { parse as parseYaml } from 'yaml'
+import { getProjectRoot } from './config'
+import type { CollectionDefinition, CollectionEntryInfo, FieldDefinition, FieldType } from './types'
+
+/** Regex patterns for type inference */
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}/
+const URL_PATTERN = /^(https?:\/\/|\/)/
+const IMAGE_EXTENSIONS = /\.(jpg|jpeg|png|gif|webp|svg|avif)$/i
+
+/** Maximum unique values before treating as free-form text instead of select */
+const MAX_SELECT_OPTIONS = 10
+
+/** Minimum length for textarea detection */
+const TEXTAREA_MIN_LENGTH = 200
+
+/** Field names that should never be inferred as select (always free-text) */
+const FREE_TEXT_FIELD_NAMES = new Set([
+	'title',
+	'name',
+	'description',
+	'summary',
+	'excerpt',
+	'subtitle',
+	'heading',
+	'headline',
+	'slug',
+	'alt',
+	'caption',
+])
+
+/**
+ * Observed values for a single field across multiple files
+ */
+interface FieldObservation {
+	name: string
+	values: unknown[]
+	presentCount: number
+	totalEntries: number
+}
+
+/**
+ * Parse YAML frontmatter from markdown content
+ */
+function parseFrontmatter(content: string): Record<string, unknown> | null {
+	const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/)
+	if (!match?.[1]) return null
+
+	return parseYaml(match[1]) as Record<string, unknown> | null
+}
+
+/**
+ * Infer the field type from a value
+ */
+function inferFieldType(value: unknown, key: string): FieldType {
+	if (value === null || value === undefined) {
+		return 'text'
+	}
+
+	if (typeof value === 'boolean') {
+		return 'boolean'
+	}
+
+	if (typeof value === 'number') {
+		return 'number'
+	}
+
+	if (Array.isArray(value)) {
+		return 'array'
+	}
+
+	if (typeof value === 'object') {
+		return 'object'
+	}
+
+	if (typeof value === 'string') {
+		// Check for date pattern
+		if (DATE_PATTERN.test(value)) {
+			return 'date'
+		}
+
+		// Check for image paths
+		if (IMAGE_EXTENSIONS.test(value)) {
+			return 'image'
+		}
+
+		// Check for image-specific field names (exact word boundaries, not substrings)
+		const lowerKey = key.toLowerCase()
+		if (/(?:^|[_-])(?:image|thumbnail|cover|avatar|logo|icon|banner|photo)(?:$|[_-])/.test(lowerKey)) {
+			return 'image'
+		}
+
+		// Check for URLs
+		if (URL_PATTERN.test(value)) {
+			return 'url'
+		}
+
+		// Check for textarea (long text or contains newlines)
+		if (value.includes('\n') || value.length > TEXTAREA_MIN_LENGTH) {
+			return 'textarea'
+		}
+
+		return 'text'
+	}
+
+	return 'text'
+}
+
+/**
+ * Merge field observations from multiple files to determine final field definition
+ */
+function mergeFieldObservations(observations: FieldObservation[]): FieldDefinition[] {
+	const fields: FieldDefinition[] = []
+
+	for (const obs of observations) {
+		const nonNullValues = obs.values.filter(v => v !== null && v !== undefined)
+		if (nonNullValues.length === 0) continue
+
+		// Determine type by consensus (most common inferred type)
+		const typeCounts = new Map<FieldType, number>()
+		for (const value of nonNullValues) {
+			const type = inferFieldType(value, obs.name)
+			typeCounts.set(type, (typeCounts.get(type) || 0) + 1)
+		}
+
+		// Get most common type
+		let fieldType: FieldType = 'text'
+		let maxCount = 0
+		for (const [type, count] of typeCounts) {
+			if (count > maxCount) {
+				maxCount = count
+				fieldType = type
+			}
+		}
+
+		const field: FieldDefinition = {
+			name: obs.name,
+			type: fieldType,
+			required: obs.presentCount === obs.totalEntries,
+			examples: nonNullValues.slice(0, 3),
+		}
+
+		// For text fields, check if we should treat as select (limited unique values)
+		if (fieldType === 'text' && !FREE_TEXT_FIELD_NAMES.has(obs.name.toLowerCase())) {
+			const uniqueValues = [...new Set(nonNullValues.map(v => String(v)))]
+			const uniqueRatio = uniqueValues.length / nonNullValues.length
+			// Only treat as select if unique values are limited AND not nearly all unique
+			// (a high unique ratio means entries have distinct values, indicating free-text)
+			if (uniqueValues.length > 0 && uniqueValues.length <= MAX_SELECT_OPTIONS && nonNullValues.length >= 2 && uniqueRatio <= 0.8) {
+				field.type = 'select'
+				field.options = uniqueValues.sort()
+			}
+		}
+
+		// For arrays, try to infer item type
+		if (fieldType === 'array') {
+			const allItems = nonNullValues.flatMap(v => (Array.isArray(v) ? v : []))
+			if (allItems.length > 0) {
+				const itemType = inferFieldType(allItems[0], obs.name)
+				field.itemType = itemType
+
+				// Check if array items should be select
+				if (itemType === 'text') {
+					const uniqueItems = [...new Set(allItems.map(v => String(v)))]
+					if (uniqueItems.length <= MAX_SELECT_OPTIONS * 2) {
+						field.options = uniqueItems.sort()
+					}
+				}
+			}
+		}
+
+		fields.push(field)
+	}
+
+	return fields
+}
+
+/**
+ * Scan a single collection directory and infer its schema
+ */
+async function scanCollection(collectionPath: string, collectionName: string, contentDir: string): Promise<CollectionDefinition | null> {
+	try {
+		const entries = await fs.readdir(collectionPath, { withFileTypes: true })
+		const markdownFiles = entries.filter(e => e.isFile() && (e.name.endsWith('.md') || e.name.endsWith('.mdx')))
+
+		if (markdownFiles.length === 0) return null
+
+		// Determine file extension (prefer md, use mdx if that's all we have)
+		const hasMd = markdownFiles.some(f => f.name.endsWith('.md'))
+		const fileExtension: 'md' | 'mdx' = hasMd ? 'md' : 'mdx'
+
+		// Collect field observations and entry info across all files
+		const fieldMap = new Map<string, FieldObservation>()
+		const entryInfos: CollectionEntryInfo[] = []
+		let hasDraft = false
+
+		for (const file of markdownFiles) {
+			const filePath = path.join(collectionPath, file.name)
+			const content = await fs.readFile(filePath, 'utf-8')
+			const frontmatter = parseFrontmatter(content)
+
+			// Collect entry info
+			const slug = file.name.replace(/\.(md|mdx)$/, '')
+			const entryInfo: CollectionEntryInfo = {
+				slug,
+				sourcePath: path.join(contentDir, collectionName, file.name),
+			}
+			if (frontmatter) {
+				if (typeof frontmatter.title === 'string') {
+					entryInfo.title = frontmatter.title
+				}
+				if (typeof frontmatter.draft === 'boolean' && frontmatter.draft) {
+					entryInfo.draft = true
+				}
+			}
+			entryInfos.push(entryInfo)
+
+			if (!frontmatter) continue
+
+			for (const [key, value] of Object.entries(frontmatter)) {
+				if (key === 'draft' && typeof value === 'boolean') {
+					hasDraft = true
+				}
+
+				let obs = fieldMap.get(key)
+				if (!obs) {
+					obs = {
+						name: key,
+						values: [],
+						presentCount: 0,
+						totalEntries: markdownFiles.length,
+					}
+					fieldMap.set(key, obs)
+				}
+
+				obs.values.push(value)
+				obs.presentCount++
+			}
+		}
+
+		// Sort entries alphabetically by title (fallback to slug)
+		entryInfos.sort((a, b) => {
+			const aLabel = a.title ?? a.slug
+			const bLabel = b.title ?? b.slug
+			return aLabel.localeCompare(bLabel)
+		})
+
+		// Update totalEntries for all observations
+		for (const obs of fieldMap.values()) {
+			obs.totalEntries = markdownFiles.length
+		}
+
+		const fields = mergeFieldObservations(Array.from(fieldMap.values()))
+
+		// Generate a human-readable label
+		const label = collectionName
+			.replace(/[-_]/g, ' ')
+			.replace(/\b\w/g, c => c.toUpperCase())
+
+		return {
+			name: collectionName,
+			label,
+			path: path.join(contentDir, collectionName),
+			entryCount: markdownFiles.length,
+			fields,
+			supportsDraft: hasDraft,
+			fileExtension,
+			entries: entryInfos,
+		}
+	} catch {
+		return null
+	}
+}
+
+/**
+ * Scan all collections in the content directory
+ */
+export async function scanCollections(contentDir: string = 'src/content'): Promise<Record<string, CollectionDefinition>> {
+	const projectRoot = getProjectRoot()
+	const fullContentDir = path.isAbsolute(contentDir) ? contentDir : path.join(projectRoot, contentDir)
+
+	const collections: Record<string, CollectionDefinition> = {}
+
+	try {
+		const entries = await fs.readdir(fullContentDir, { withFileTypes: true })
+
+		const scanPromises = entries
+			.filter(entry => entry.isDirectory() && !entry.name.startsWith('_') && !entry.name.startsWith('.'))
+			.map(async entry => {
+				const collectionPath = path.join(fullContentDir, entry.name)
+				const definition = await scanCollection(collectionPath, entry.name, contentDir)
+				if (definition) {
+					collections[entry.name] = definition
+				}
+			})
+
+		await Promise.all(scanPromises)
+	} catch {
+		// Content directory doesn't exist or isn't readable
+	}
+
+	return collections
+}

package/src/component-registry.ts

@@ -0,0 +1,393 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { getProjectRoot } from './config'
+import { getErrorCollector } from './error-collector'
+import type { ComponentDefinition, ComponentProp } from './types'
+
+/**
+ * Scans Astro component files and extracts their definitions including props
+ */
+export class ComponentRegistry {
+	private components: Map<string, ComponentDefinition> = new Map()
+	private componentDirs: string[]
+
+	constructor(componentDirs: string[] = ['src/components']) {
+		this.componentDirs = componentDirs
+	}
+
+	/**
+	 * Scan all component directories and build the registry
+	 */
+	async scan(): Promise<void> {
+		for (const dir of this.componentDirs) {
+			const fullPath = path.join(getProjectRoot(), dir)
+			try {
+				await this.scanDirectory(fullPath, dir)
+			} catch {
+				// Directory doesn't exist, skip
+			}
+		}
+	}
+
+	/**
+	 * Get all registered components
+	 */
+	getComponents(): Record<string, ComponentDefinition> {
+		return Object.fromEntries(this.components)
+	}
+
+	/**
+	 * Get a specific component by name
+	 */
+	getComponent(name: string): ComponentDefinition | undefined {
+		return this.components.get(name)
+	}
+
+	/**
+	 * Scan a directory recursively for .astro files
+	 */
+	private async scanDirectory(dir: string, relativePath: string): Promise<void> {
+		const entries = await fs.readdir(dir, { withFileTypes: true })
+
+		for (const entry of entries) {
+			const fullPath = path.join(dir, entry.name)
+			const relPath = path.join(relativePath, entry.name)
+
+			if (entry.isDirectory()) {
+				await this.scanDirectory(fullPath, relPath)
+			} else if (entry.isFile() && entry.name.endsWith('.astro')) {
+				await this.parseComponent(fullPath, relPath)
+			}
+		}
+	}
+
+	/**
+	 * Parse a single Astro component file
+	 */
+	private async parseComponent(filePath: string, relativePath: string): Promise<void> {
+		try {
+			const content = await fs.readFile(filePath, 'utf-8')
+			const componentName = path.basename(filePath, '.astro')
+
+			const props = await this.extractProps(content)
+			const slots = this.extractSlots(content)
+			const description = this.extractDescription(content)
+			const previewWidth = this.extractPreviewWidth(content)
+
+			this.components.set(componentName, {
+				name: componentName,
+				file: relativePath,
+				props,
+				slots: slots.length > 0 ? slots : undefined,
+				description,
+				previewWidth,
+			})
+		} catch (error) {
+			console.warn(`[ComponentRegistry] Failed to parse ${filePath}:`, error)
+		}
+	}
+
+	/**
+	 * Parse Props content and extract individual property definitions
+	 * Handles multi-line properties with nested types
+	 */
+	private parsePropsContent(propsContent: string): ComponentProp[] {
+		const props: ComponentProp[] = []
+		let i = 0
+		const content = propsContent.trim()
+
+		while (i < content.length) {
+			// Skip whitespace and newlines
+			while (i < content.length && /\s/.test(content[i] ?? '')) i++
+			if (i >= content.length) break
+
+			// Skip comments
+			if (content[i] === '/' && content[i + 1] === '/') {
+				// Skip to end of line
+				while (i < content.length && content[i] !== '\n') i++
+				continue
+			}
+
+			if (content[i] === '/' && content[i + 1] === '*') {
+				// Skip block comment
+				while (i < content.length - 1 && !(content[i] === '*' && content[i + 1] === '/')) i++
+				i += 2
+				continue
+			}
+
+			// Extract property name
+			const nameStart = i
+			while (i < content.length && /\w/.test(content[i] ?? '')) i++
+			const name = content.substring(nameStart, i)
+
+			if (!name) break
+
+			// Skip whitespace
+			while (i < content.length && /\s/.test(content[i] ?? '')) i++
+
+			// Check for optional marker
+			const optional = content[i] === '?'
+			if (optional) i++
+
+			// Skip whitespace
+			while (i < content.length && /\s/.test(content[i] ?? '')) i++
+
+			// Expect colon
+			if (content[i] !== ':') break
+			i++
+
+			// Skip whitespace
+			while (i < content.length && /\s/.test(content[i] ?? '')) i++
+
+			// Extract type (up to semicolon, handling nested braces)
+			const typeStart = i
+			let braceDepth = 0
+			let angleDepth = 0
+			while (i < content.length) {
+				if (content[i] === '{') braceDepth++
+				else if (content[i] === '}') braceDepth--
+				else if (content[i] === '<') angleDepth++
+				else if (content[i] === '>') angleDepth--
+				else if (content[i] === ';' && braceDepth === 0 && angleDepth === 0) break
+				i++
+			}
+
+			const type = content.substring(typeStart, i).trim()
+
+			// Skip the semicolon
+			if (content[i] === ';') i++
+
+			// Skip whitespace
+			while (i < content.length && /[ \t]/.test(content[i] ?? '')) i++
+
+			// Check for inline comment
+			let description: string | undefined
+			if (content[i] === '/' && content[i + 1] === '/') {
+				i += 2
+				const commentStart = i
+				while (i < content.length && content[i] !== '\n') i++
+				description = content.substring(commentStart, i).trim()
+			}
+
+			if (name && type) {
+				props.push({
+					name,
+					type,
+					required: !optional,
+					description,
+				})
+			}
+		}
+
+		return props
+	}
+
+	/**
+	 * Extract content between balanced braces after a pattern match
+	 * Properly handles nested objects
+	 */
+	private extractBalancedBraces(text: string, pattern: RegExp): string | null {
+		const match = text.match(pattern)
+		if (!match || match.index === undefined) return null
+
+		// Find the opening brace position (right after the match)
+		const startIndex = match.index + match[0].length
+		let depth = 1 // We already have one opening brace
+		let i = startIndex
+
+		// Find the matching closing brace
+		while (i < text.length && depth > 0) {
+			if (text[i] === '{') {
+				depth++
+			} else if (text[i] === '}') {
+				depth--
+			}
+			i++
+		}
+
+		if (depth !== 0) return null // Unbalanced braces
+
+		// Extract content between braces (excluding the braces themselves)
+		return text.substring(startIndex, i - 1)
+	}
+
+	/**
+	 * Extract props from component frontmatter
+	 */
+	private async extractProps(content: string): Promise<ComponentProp[]> {
+		const props: ComponentProp[] = []
+
+		// Find the frontmatter section
+		const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/)
+		if (!frontmatterMatch?.[1]) return props
+
+		const frontmatter = frontmatterMatch[1]
+
+		// Look for Props interface
+		const propsInterfaceContent = this.extractBalancedBraces(frontmatter, /interface\s+Props\s*\{/)
+		if (propsInterfaceContent) {
+			const extractedProps = this.parsePropsContent(propsInterfaceContent)
+			props.push(...extractedProps)
+		}
+
+		// Look for type Props = { ... }
+		if (props.length === 0) {
+			const typePropsContent = this.extractBalancedBraces(frontmatter, /type\s+Props\s*=\s*\{/)
+			if (typePropsContent) {
+				const extractedProps = this.parsePropsContent(typePropsContent)
+				props.push(...extractedProps)
+			}
+		}
+
+		const destructureMatch = frontmatter?.match(/const\s*\{([^}]+)\}\s*=\s*Astro\.props/)
+		if (destructureMatch) {
+			const destructureContent = destructureMatch[1]
+
+			const defaultMatches = destructureContent?.matchAll(/(\w+)\s*=\s*(['"`]?)([^'"`},]+)\2/g) ?? []
+			for (const match of defaultMatches) {
+				const propName = match[1]
+				const defaultValue = match[3]
+				const existingProp = props.find(p => p.name === propName)
+				if (existingProp) {
+					existingProp.defaultValue = defaultValue
+				}
+			}
+		}
+
+		return props
+	}
+
+	/**
+	 * Extract slot names from template
+	 */
+	private extractSlots(content: string): string[] {
+		const slots: string[] = []
+
+		// Find <slot> elements with name attribute
+		const slotMatches = content.matchAll(/<slot\s+name=["']([^"']+)["']/g)
+		for (const match of slotMatches) {
+			if (match[1]) {
+				slots.push(match[1])
+			}
+		}
+
+		// Check for default slot (unnamed slot) - match any <slot> tag without a name attribute
+		const allSlotTags = content.matchAll(/<slot(?:\s+[^>]*)?\s*\/?>/g)
+		for (const match of allSlotTags) {
+			const tag = match[0]
+			// Check if this slot tag doesn't have a name attribute
+			if (!/name\s*=/.test(tag)) {
+				if (!slots.includes('default')) {
+					slots.unshift('default')
+				}
+				break // Only need to find one default slot
+			}
+		}
+
+		return slots
+	}
+
+	/**
+	 * Extract component description from JSDoc comment
+	 */
+	private extractDescription(content: string): string | undefined {
+		// Look for JSDoc comment at the start of frontmatter
+		const match = content.match(/^---\n\/\*\*\s*([\s\S]*?)\s*\*\//)
+		if (match?.[1]) {
+			return match[1]
+				.split('\n')
+				.map(line => line.replace(/^\s*\*\s?/, '').trim())
+				.filter(Boolean)
+				.join(' ')
+		}
+		return undefined
+	}
+
+	/**
+	 * Extract @previewWidth value from JSDoc comment
+	 */
+	private extractPreviewWidth(content: string): number | undefined {
+		const match = content.match(/^---\n\/\*\*\s*([\s\S]*?)\s*\*\//)
+		if (match?.[1]) {
+			const widthMatch = match[1].match(/@previewWidth\s+(\d+)/)
+			if (widthMatch?.[1]) {
+				return parseInt(widthMatch[1], 10)
+			}
+		}
+		return undefined
+	}
+}
+
+/**
+ * Parse component usage in an Astro file to extract prop values
+ */
+export function parseComponentUsage(
+	content: string,
+	componentName: string,
+): Array<{ line: number; props: Record<string, string> }> {
+	const usages: Array<{ line: number; props: Record<string, string> }> = []
+	const lines = content.split('\n')
+
+	// Match component usage: <ComponentName prop="value" />
+	const componentRegex = new RegExp(
+		`<${componentName}\\s+([^>]*?)\\s*\\/?>`,
+		'g',
+	)
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i]
+		const lineMatches = line?.matchAll(new RegExp(componentRegex.source, 'g')) || []
+
+		for (const match of lineMatches) {
+			const propsString = match[1]
+			const props = parsePropsString(propsString)
+
+			usages.push({
+				line: i + 1,
+				props,
+			})
+		}
+	}
+
+	return usages
+}
+
+/**
+ * Parse props string from component tag
+ */
+function parsePropsString(propsString?: string): Record<string, string> {
+	const props: Record<string, string> = {}
+	if (!propsString) return props
+
+	// Match prop="value" or prop='value' or prop={expression} or prop (boolean)
+	// For expressions, handle nested braces by counting depth
+	const regex = /(\w+)(?:=(?:"([^"]*)"|'([^']*)'|\{))?/g
+	let match: RegExpExecArray | null
+	while ((match = regex.exec(propsString)) !== null) {
+		const name = match[1]
+		if (!name) continue
+
+		if (match[2] !== undefined) {
+			props[name] = match[2]
+		} else if (match[3] !== undefined) {
+			props[name] = match[3]
+		} else if (match[0].endsWith('{')) {
+			// Expression: count braces to find the matching close
+			let depth = 1
+			const start = regex.lastIndex
+			let i = start
+			while (i < propsString.length && depth > 0) {
+				if (propsString[i] === '{') depth++
+				else if (propsString[i] === '}') depth--
+				i++
+			}
+			props[name] = propsString.slice(start, i - 1)
+			regex.lastIndex = i
+		} else {
+			// Boolean prop
+			props[name] = 'true'
+		}
+	}
+
+	return props
+}