@nuasite/cli 0.51.0 → 0.53.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuasite/cli",
-  "version": "0.51.0",
+  "version": "0.53.0",
   "license": "Apache-2.0",
   "type": "module",
   "files": [
@@ -23,8 +23,10 @@
     "prepack": "bun run ../../scripts/workspace-deps/resolve-deps.ts"
   },
   "dependencies": {
-    "@nuasite/cms": "0.51.0",
-    "@nuasite/cms-core": "0.51.0"
+    "@astrojs/compiler": "^3.0.1",
+    "@jridgewell/trace-mapping": "^0.3.31",
+    "@nuasite/cms": "0.53.0",
+    "@nuasite/cms-core": "0.53.0"
   },
   "devDependencies": {
     "@types/bun": "1.3.11"

package/src/check-code.ts

@@ -0,0 +1,133 @@
+/**
+ * Syntax check for the project's own code.
+ *
+ * A full build catches these, but it renders every page to get there. What actually fails is the
+ * parse: Astro compiles a `.astro` file to TypeScript and the bundler parses that, so compiling
+ * and parsing — without rendering anything — reproduces the same class of error in about a second.
+ *
+ * This is a *syntax* check, not a type check. A wrong prop type or a missing export still needs
+ * `astro check` or a build. What it does catch is the error that stops a build dead before a single
+ * page renders — an unescaped quote inside a Czech string being the one that prompted it.
+ */
+
+import { transform } from '@astrojs/compiler'
+import { originalPositionFor, TraceMap } from '@jridgewell/trace-mapping'
+import type { CheckFinding } from '@nuasite/cms-core'
+import { Glob } from 'bun'
+import path from 'node:path'
+
+/** Directories that are never the project's own source. */
+const IGNORED = ['node_modules', 'dist', '.astro', '.git', '.output', '.vercel', '.netlify']
+
+const isIgnored = (relative: string): boolean =>
+	// Declaration files are types only — nothing compiles them, and the TS loader rejects them.
+	/\.d\.[mc]?ts$/.test(relative) || relative.split(path.sep).some(segment => IGNORED.includes(segment))
+
+/** Bun's parser reports a `BuildMessage` carrying the offending position in the code it was given. */
+interface BuildPosition {
+	line?: number
+	column?: number
+	lineText?: string
+}
+
+function buildPosition(error: unknown): BuildPosition | null {
+	if (typeof error !== 'object' || error === null || !('position' in error)) return null
+	const position = (error as { position: unknown }).position
+	return typeof position === 'object' && position !== null ? position as BuildPosition : null
+}
+
+/** Bun's `BuildMessage` is not an `Error`, so `String(error)` would prefix the class name. */
+function messageOf(error: unknown): string {
+	const message = typeof error === 'object' && error !== null && 'message' in error ? (error as { message: unknown }).message : undefined
+	return String(typeof message === 'string' ? message : error).split('\n')[0]!
+}
+
+/**
+ * Map a position in the emitted TypeScript back to the `.astro` source.
+ *
+ * Without this the position points into generated `$$render` code, which is worse than no position
+ * at all — it looks like a real line number and is not one.
+ */
+function toSource(map: string | undefined, position: BuildPosition | null): { line?: number; column?: number } {
+	if (!map || position?.line === undefined) return {}
+	try {
+		const traced = originalPositionFor(new TraceMap(JSON.parse(map)), {
+			line: position.line,
+			column: position.column ?? 0,
+		})
+		if (traced.line === null) return {}
+		// trace-mapping columns are 0-based; editors and build output are not.
+		return { line: traced.line, column: traced.column + 1 }
+	} catch {
+		return {}
+	}
+}
+
+async function checkAstroFile(absolute: string, relative: string, source: string): Promise<CheckFinding | null> {
+	let emitted: { code: string; map: string }
+	try {
+		emitted = await transform(source, { filename: absolute, sourcemap: 'both' })
+	} catch (error) {
+		return { severity: 'error', code: 'code/astro-parse', file: relative, message: messageOf(error) }
+	}
+
+	try {
+		new Bun.Transpiler({ loader: 'ts' }).transformSync(emitted.code)
+		return null
+	} catch (error) {
+		const position = buildPosition(error)
+		return {
+			severity: 'error',
+			code: 'code/syntax',
+			file: relative,
+			...toSource(emitted.map, position),
+			message: messageOf(error),
+		}
+	}
+}
+
+function checkScriptFile(relative: string, source: string, loader: 'ts' | 'tsx'): CheckFinding | null {
+	try {
+		new Bun.Transpiler({ loader }).transformSync(source)
+		return null
+	} catch (error) {
+		const position = buildPosition(error)
+		return {
+			severity: 'error',
+			code: 'code/syntax',
+			file: relative,
+			line: position?.line,
+			column: position?.column === undefined ? undefined : position.column + 1,
+			message: messageOf(error),
+		}
+	}
+}
+
+export interface CodeCheckResult {
+	findings: CheckFinding[]
+	files: number
+}
+
+/** Parse every `.astro`/`.ts`/`.tsx` under `root`, newest failure first is not meaningful here — order is by path. */
+export async function checkCode(root: string): Promise<CodeCheckResult> {
+	const findings: CheckFinding[] = []
+	let files = 0
+
+	const paths: string[] = []
+	for await (const relative of new Glob('**/*.{astro,ts,tsx,mts,cts}').scan({ cwd: root })) {
+		if (!isIgnored(relative)) paths.push(relative)
+	}
+	paths.sort()
+
+	for (const relative of paths) {
+		files++
+		const absolute = path.join(root, relative)
+		const source = await Bun.file(absolute).text()
+		const finding = relative.endsWith('.astro')
+			? await checkAstroFile(absolute, relative, source)
+			: checkScriptFile(relative, source, relative.endsWith('.tsx') ? 'tsx' : 'ts')
+		if (finding) findings.push(finding)
+	}
+
+	return { findings, files }
+}

package/src/check.ts

@@ -1,28 +1,91 @@
-import { checkContent, createNodeFs, formatCheckReport } from '@nuasite/cms-core'
+import { checkContent, type CheckReport, createNodeFs, formatCheckReport } from '@nuasite/cms-core'
+import { existsSync, readdirSync } from 'node:fs'
+import path from 'node:path'
+import { checkCode } from './check-code'
 
 export interface CheckOptions {
 	cwd: string
 	json: boolean
 	/** Treat warnings as failures too. Off by default: a dangling reference builds fine. */
 	strict: boolean
+	/** Skip the code syntax pass — content only. */
+	contentOnly: boolean
+}
+
+const ASTRO_CONFIG_NAMES = ['astro.config.ts', 'astro.config.mts', 'astro.config.mjs', 'astro.config.js']
+
+const hasAstroConfig = (dir: string): boolean => ASTRO_CONFIG_NAMES.some(name => existsSync(path.join(dir, name)))
+
+/**
+ * The Astro apps to check, relative to `cwd`.
+ *
+ * Running this at a monorepo root has to work: that is where an agent's workspace and a
+ * developer's shell both start, and `bun run build` there builds something else entirely
+ * (admin, api, worker). Every `packages/*` app is checked, not just the first — a repo with
+ * two sites must not have one of them silently skipped.
+ */
+export function astroRoots(cwd: string): string[] {
+	if (hasAstroConfig(cwd)) return ['.']
+
+	const packagesDir = path.join(cwd, 'packages')
+	if (!existsSync(packagesDir)) return []
+
+	return readdirSync(packagesDir, { withFileTypes: true })
+		.filter(entry => entry.isDirectory())
+		.map(entry => entry.name)
+		.sort()
+		.filter(name => hasAstroConfig(path.join(packagesDir, name)))
+		.map(name => path.join('packages', name))
+}
+
+/** Re-root a sub-project's findings on the directory the command was run from. */
+function prefixed(report: CheckReport, root: string): CheckReport {
+	if (root === '.') return report
+	return {
+		...report,
+		findings: report.findings.map(finding => ({ ...finding, file: path.join(root, finding.file) })),
+	}
 }
 
 /** Validate the content collections and return the process exit code. */
 export async function check(options: CheckOptions): Promise<number> {
-	const report = await checkContent(createNodeFs(options.cwd))
+	const roots = astroRoots(options.cwd)
 
-	if (options.json) {
-		console.log(JSON.stringify(report, null, 2))
-	} else {
-		const formatted = formatCheckReport(report)
-		if (formatted) console.log(formatted + '\n')
+	if (roots.length === 0) {
+		console.error(`No astro.config.* found in ${options.cwd} or its packages/*. Run this in an Astro project.`)
+		return 1
+	}
+
+	const reports = await Promise.all(roots.map(async root => {
+		const absolute = path.join(options.cwd, root)
+		const content = prefixed(await checkContent(createNodeFs(absolute)), root)
+		if (options.contentOnly) return { ...content, files: 0 }
+		const code = await checkCode(absolute)
+		return {
+			...content,
+			findings: [...content.findings, ...code.findings.map(finding => ({ ...finding, file: path.join(root, finding.file) }))],
+			files: code.files,
+		}
+	}))
+
+	const report: CheckReport = {
+		findings: reports.flatMap(one => one.findings),
+		collections: reports.reduce((total, one) => total + one.collections, 0),
+		entries: reports.reduce((total, one) => total + one.entries, 0),
 	}
+	const sourceFiles = reports.reduce((total, one) => total + one.files, 0)
 
 	const errors = report.findings.filter(finding => finding.severity === 'error').length
 	const warnings = report.findings.length - errors
 
-	if (!options.json) {
-		const counts = `${report.collections} collection(s), ${report.entries} entries`
+	if (options.json) {
+		console.log(JSON.stringify({ ...report, roots }, null, 2))
+	} else {
+		const formatted = formatCheckReport(report)
+		if (formatted) console.log(formatted + '\n')
+		const where = roots.length === 1 && roots[0] === '.' ? '' : ` in ${roots.join(', ')}`
+		const code = options.contentOnly ? '' : `, ${sourceFiles} source file(s)`
+		const counts = `${report.collections} collection(s), ${report.entries} entries${code}${where}`
 		console.log(errors === 0 && warnings === 0 ? `${counts} — no problems found` : `${counts} — ${errors} error(s), ${warnings} warning(s)`)
 	}
 

package/src/index.ts

@@ -25,7 +25,7 @@ function printUsage() {
 	console.log('  build              Run astro build with the Nua defaults')
 	console.log('  dev                Run astro dev with the Nua defaults')
 	console.log('  preview            Run astro preview with the Nua defaults')
-	console.log('  check              Validate the content collections (no build). --json, --strict')
+	console.log('  check              Validate collections and parse the source (no build). --json, --strict, --content-only')
 	console.log('  init               Convert a standard Astro project to use Nua')
 	console.log('  clean              Eject to a standard Astro project (remove @nuasite/* deps)')
 	console.log('  migrate <target>   Run a content migration. Targets: astro-image')
@@ -44,6 +44,7 @@ if (command && ['build', 'dev', 'preview'].includes(command)) {
 					cwd: process.cwd(),
 					json: args.includes('--json'),
 					strict: args.includes('--strict'),
+					contentOnly: args.includes('--content-only'),
 				}),
 			)
 			break