@nuasite/cli 0.65.3 → 0.66.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuasite/cli",
-  "version": "0.65.3",
+  "version": "0.66.0",
   "license": "Apache-2.0",
   "type": "module",
   "files": [
@@ -25,8 +25,9 @@
   "dependencies": {
     "@astrojs/compiler": "^4.0.0",
     "@jridgewell/trace-mapping": "^0.3.31",
-    "@nuasite/cms": "0.65.3",
-    "@nuasite/cms-core": "0.65.3"
+    "@nuasite/cms": "0.66.0",
+    "@nuasite/cms-core": "0.66.0",
+    "tailwindcss": "4.2.2"
   },
   "devDependencies": {
     "@types/bun": "1.3.11"

package/src/check-code.ts

@@ -8,17 +8,29 @@
  * 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.
+ *
+ * Stylesheets are parsed the way the build parses them. A Nua site builds with Tailwind's Vite
+ * plugin, which runs every stylesheet through Tailwind's CSS parser, Tailwind or not, and that
+ * parser refuses what a browser quietly repairs: a rule cut off before its closing brace failed a
+ * whole site's build while the editor preview, which concatenates the files, only lost its styles.
  */
 
 import { transform } from '@astrojs/compiler'
 import { originalPositionFor, TraceMap } from '@jridgewell/trace-mapping'
 import type { CheckFinding } from '@nuasite/cms-core'
 import { Glob } from 'bun'
+import { createRequire } from 'node:module'
 import path from 'node:path'
+import { compile as bundledCompile } from 'tailwindcss'
+
+type Compile = typeof bundledCompile
 
 /** Directories that are never the project's own source. */
 const IGNORED = ['node_modules', 'dist', '.astro', '.git', '.output', '.vercel', '.netlify']
 
+/** Copied to the output as they are: nothing parses them, so nothing in them can fail a build. */
+const UNPROCESSED_STYLESHEETS = ['public']
+
 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))
@@ -103,31 +115,110 @@ function checkScriptFile(relative: string, source: string, loader: 'ts' | 'tsx')
 	}
 }
 
+/**
+ * The parser's own syntax errors. Compiling a stylesheet alone also reports what only the whole
+ * project could settle (`@apply` of a utility its theme defines, a `@reference` it needs), and those
+ * are left to the build.
+ */
+const CSS_SYNTAX_ERROR = /^(Missing closing|Missing opening|Unterminated string|Invalid declaration)/
+
+/** A Tailwind `CssSyntaxError`: its message is `<from>:<line>:<column>: <what>`, its `loc` the offsets into the source. */
+function cssSyntaxError(error: unknown): { message: string; offset: number | null } | null {
+	if (!(error instanceof Error)) return null
+	const message = error.message.replace(/^.*?:\d+:\d+: /, '')
+	if (!CSS_SYNTAX_ERROR.test(message)) return null
+	const loc = 'loc' in error && Array.isArray(error.loc) ? error.loc : null
+	const offset = loc && typeof loc[1] === 'number' ? loc[1] : null
+	return { message, offset }
+}
+
+/** 1-based line and column of an offset, the way editors and build output count them. */
+function lineAndColumn(source: string, offset: number): { line: number; column: number } {
+	const before = source.slice(0, offset)
+	const line = before.split('\n').length
+	return { line, column: offset - before.lastIndexOf('\n') }
+}
+
+/**
+ * The site's own Tailwind when it has one, else the copy this CLI ships. Its parser's strictness moved between
+ * versions (4.0 accepts `color red;`, 4.1 refuses it), and the check has to refuse what the site's build refuses.
+ */
+async function compileFor(root: string): Promise<Compile> {
+	try {
+		const module: unknown = await import(createRequire(path.join(root, 'package.json')).resolve('tailwindcss'))
+		if (typeof module === 'object' && module !== null && 'compile' in module && typeof module.compile === 'function') {
+			return module.compile as Compile
+		}
+	} catch {
+		// Not installed in the site, or not loadable from here: the bundled parser is the next best judge.
+	}
+	return bundledCompile
+}
+
+async function checkCssFile(compile: Compile, absolute: string, relative: string, source: string): Promise<CheckFinding | null> {
+	try {
+		// Imports and plugins resolve to nothing: each stylesheet is parsed on its own, and loading the
+		// project's would only add errors that are not syntax.
+		await compile(source, {
+			base: path.dirname(absolute),
+			from: relative,
+			loadStylesheet: async (id, base) => ({ path: id, base, content: '' }),
+			loadModule: async (id, base) => ({ path: id, base, module: () => {} }),
+		})
+		return null
+	} catch (error) {
+		const syntax = cssSyntaxError(error)
+		if (!syntax) return null
+		return {
+			severity: 'error',
+			code: 'code/css-syntax',
+			file: relative,
+			...(syntax.offset === null ? {} : lineAndColumn(source, syntax.offset)),
+			message: syntax.message,
+		}
+	}
+}
+
 export interface CodeCheckResult {
 	findings: CheckFinding[]
 	files: number
+	/** The files parsed, relative to the root: what `--fail-on` can vouch for. */
+	paths: string[]
+}
+
+export interface CodeCheckOptions {
+	/**
+	 * May the check load the project's own packages? Its `tailwindcss` is the site's real parser, but loading it runs
+	 * the project's installed code, which `--no-live` promises not to do; the bundled parser stands in then.
+	 */
+	projectCode: boolean
 }
 
-/** 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> {
+/** Parse every `.astro`/`.ts`/`.tsx`/`.css` under `root`; order is by path. */
+export async function checkCode(root: string, { projectCode }: CodeCheckOptions = { projectCode: false }): 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)
+	for await (const relative of new Glob('**/*.{astro,ts,tsx,mts,cts,css}').scan({ cwd: root })) {
+		if (isIgnored(relative)) continue
+		if (relative.endsWith('.css') && UNPROCESSED_STYLESHEETS.includes(relative.split(path.sep)[0]!)) continue
+		paths.push(relative)
 	}
 	paths.sort()
 
+	const compile = projectCode && paths.some(relative => relative.endsWith('.css')) ? await compileFor(root) : bundledCompile
 	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)
+			: relative.endsWith('.css')
+			? await checkCssFile(compile, absolute, relative, source)
 			: checkScriptFile(relative, source, relative.endsWith('.tsx') ? 'tsx' : 'ts')
 		if (finding) findings.push(finding)
 	}
 
-	return { findings, files }
+	return { findings, files, paths }
 }

package/src/check.ts

@@ -13,6 +13,11 @@ export interface CheckOptions {
 	contentOnly: boolean
 	/** Validate against the project's real schemas, which means importing and running its content config. */
 	live: boolean
+	/**
+	 * Fail only on errors in these files, relative to `cwd`; every finding is still reported. For a commit
+	 * that must not add a broken file but should not be blocked by one it did not touch.
+	 */
+	failOn: string[] | null
 }
 
 /**
@@ -24,6 +29,7 @@ export interface CheckOptions {
 export function parseCheckArgs(args: string[], cwd: string): CheckOptions {
 	const contentOnly = args.includes('--content-only')
 	return {
+		failOn: parseFailOn(args),
 		cwd,
 		json: args.includes('--json'),
 		strict: args.includes('--strict'),
@@ -33,6 +39,15 @@ export function parseCheckArgs(args: string[], cwd: string): CheckOptions {
 	}
 }
 
+/** `--fail-on a.css,b.astro` or `--fail-on=a.css,b.astro`, as normalized relative paths; null without the flag. */
+function parseFailOn(args: string[]): string[] | null {
+	const index = args.findIndex(arg => arg === '--fail-on' || arg.startsWith('--fail-on='))
+	if (index === -1) return null
+	const flag = args[index]!
+	const value = flag === '--fail-on' ? args[index + 1] ?? '' : flag.slice('--fail-on='.length)
+	return value.split(',').map(file => file.trim()).filter(Boolean).map(file => path.normalize(file))
+}
+
 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)))
@@ -102,12 +117,13 @@ export async function check(options: CheckOptions): Promise<number> {
 	const reports = await Promise.all(roots.map(async root => {
 		const absolute = path.join(options.cwd, root)
 		const content = prefixed(await checkContent(createNodeFs(absolute), schemas ? { schemas } : {}), root)
-		if (options.contentOnly) return { ...content, files: 0 }
-		const code = await checkCode(absolute)
+		if (options.contentOnly) return { ...content, files: 0, paths: [] }
+		const code = await checkCode(absolute, { projectCode: options.live })
 		return {
 			...content,
 			findings: [...content.findings, ...code.findings.map(finding => ({ ...finding, file: path.join(root, finding.file) }))],
 			files: code.files,
+			paths: code.paths.map(file => path.join(root, file)),
 		}
 	}))
 
@@ -120,10 +136,21 @@ export async function check(options: CheckOptions): Promise<number> {
 
 	const errors = report.findings.filter(finding => finding.severity === 'error').length
 	const warnings = report.findings.length - errors
+	// An agent may list a file by its absolute path; findings are relative to the cwd.
+	const failOn = options.failOn === null ? null : new Set(options.failOn.map(file => path.relative(options.cwd, path.resolve(options.cwd, file))))
+	// Under --strict a warning in a listed file fails as well, as it would without --fail-on.
+	const failing = failOn === null
+		? errors
+		: report.findings.filter(finding => (finding.severity === 'error' || options.strict) && failOn.has(path.normalize(finding.file))).length
+	// A listed file the syntax pass did not read, e.g. a `.js`, one in `public/` or outside every Astro project:
+	// nothing here parsed it, so it is named rather than counted, and the summary cannot read as a pass for it.
+	const parsed = new Set(reports.flatMap(one => one.paths))
+	const unchecked = failOn === null ? [] : [...failOn].filter(file => !parsed.has(file))
 
 	if (options.json) {
 		// The reason belongs inside the payload: a stray line would break anything parsing this.
-		console.log(JSON.stringify({ ...report, roots, liveSchemas: 'schemas' in live ? 'ran' : live.skipped }, null, 2))
+		const failOnErrors = failOn === null ? {} : { failOnErrors: failing, failOnUnchecked: unchecked }
+		console.log(JSON.stringify({ ...report, roots, liveSchemas: 'schemas' in live ? 'ran' : live.skipped, ...failOnErrors }, null, 2))
 	} else {
 		const formatted = formatCheckReport(report)
 		if (formatted) console.log(formatted + '\n')
@@ -133,7 +160,19 @@ export async function check(options: CheckOptions): Promise<number> {
 		console.log(errors === 0 && warnings === 0 ? `${counts} — no problems found` : `${counts} — ${errors} error(s), ${warnings} warning(s)`)
 		// A check that did not run must not read as a pass.
 		if ('skipped' in live) console.log(`Live schema rules did not run: ${live.skipped}`)
+		if (failOn !== null) {
+			const covered = failOn.size - unchecked.length
+			console.log(
+				failing === 0
+					? `No errors in the ${covered} file(s) given to --fail-on that were checked.`
+					: `${failing} problem(s) in the files given to --fail-on. Fix them before going on.`,
+			)
+			if (unchecked.length > 0) {
+				console.log(`Not parsed by this run (a content entry is still checked with its collection): ${unchecked.join(', ')}`)
+			}
+		}
 	}
 
+	if (failOn !== null) return failing > 0 ? 1 : 0
 	return errors > 0 || (options.strict && warnings > 0) ? 1 : 0
 }

package/src/index.ts

@@ -25,7 +25,9 @@ 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 collections and parse the source (no build). --json, --strict, --content-only, --no-live')
+	console.log('  check              Validate collections and parse the source (no build). --json, --strict, --content-only, --no-live,')
+	console.log('                     --fail-on <file,...> (fail only on errors in these files). --no-live also keeps the')
+	console.log("                     project's own tailwindcss unloaded; stylesheets are then parsed with the bundled one")
 	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')