cluaupp 1.0.0 → 1.3.0

package/src/clpp/runner.ts

@@ -1,22 +1,127 @@
-import { spawnSync } from "node:child_process";
-import { CLPP_INSTALL_HINT, type CompileArtifact, type CompileRequest, type LanguageManifest } from "./contract.js";
+import { spawn, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+	CLPP_INSTALL_HINT,
+	MIN_CLPP_VERSION,
+	type CompileArtifact,
+	type CompileDiagnostic,
+	type CompileRequest,
+	type LanguageManifest,
+} from "./contract.js";
 
 const MISSING_CLPP = `cluaupp: clpp not found. ${CLPP_INSTALL_HINT}`;
 
-function whichClpp(): string | null {
-	if (process.env.CLPP_PATH) {
-		return process.env.CLPP_PATH;
+type Semver = { major: number; minor: number; patch: number };
+
+let cachedBin: string | null | undefined;
+
+function parseSemver(text: string): Semver | null {
+	const match = String(text).match(/(\d+)\.(\d+)\.(\d+)/);
+	if (!match) {
+		return null;
 	}
+	return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]) };
+}
+
+function cmpSemver(a: Semver, b: Semver): number {
+	return a.major - b.major || a.minor - b.minor || a.patch - b.patch;
+}
+
+function minClpp(): Semver {
+	return parseSemver(MIN_CLPP_VERSION) || { major: 0, minor: 3, patch: 2 };
+}
+
+function tooOldMessage(bin: string, version: string | null): string {
+	return `cluaupp: clpp ${version || "unknown"} is too old (${bin}). Need CL++ ${MIN_CLPP_VERSION}+. Install https://github.com/KartzRbx/CLPP/releases/download/v0.3.2/clpp-setup.exe or set CLPP / CLPP_PATH.`;
+}
+
+function probeVersion(bin: string): string | null {
+	const result = spawnSync(bin, ["--version"], { encoding: "utf8", windowsHide: true });
+	if (result.status !== 0) {
+		return null;
+	}
+	return String(result.stdout || result.stderr || "").trim() || null;
+}
+
+function pushCandidate(out: string[], seen: Set<string>, item: string | undefined): void {
+	const value = String(item || "").trim();
+	if (!value) {
+		return;
+	}
+	const key = value.toLowerCase();
+	if (seen.has(key)) {
+		return;
+	}
+	seen.add(key);
+	out.push(value);
+}
+
+function existsBin(bin: string): boolean {
+	try {
+		return fs.existsSync(bin);
+	} catch {
+		return false;
+	}
+}
+
+function listClppCandidates(): string[] {
+	const seen = new Set<string>();
+	const override: string[] = [];
+	pushCandidate(override, seen, process.env.CLPP);
+	pushCandidate(override, seen, process.env.CLPP_PATH);
+	const overrideExisting = override.filter(existsBin);
+	if (overrideExisting.length > 0) {
+		return overrideExisting;
+	}
+
+	const out: string[] = [];
 	const finder = process.platform === "win32" ? "where" : "which";
 	const found = spawnSync(finder, ["clpp"], { encoding: "utf8", windowsHide: true });
-	if (found.status !== 0) {
+	if (found.status === 0) {
+		for (const line of String(found.stdout || "").split(/\r?\n/)) {
+			pushCandidate(out, seen, line);
+		}
+	}
+
+	if (process.platform === "win32") {
+		const local = process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
+		pushCandidate(out, seen, path.join(local, "Programs", "CLPP", "clpp.exe"));
+	}
+
+	return out.filter(existsBin);
+}
+
+function pickClppBinary(): string | null {
+	const candidates = listClppCandidates();
+	if (candidates.length === 0) {
 		return null;
 	}
-	const line = String(found.stdout || "")
-		.split(/\r?\n/)
-		.map((item) => item.trim())
-		.find((item) => item.length > 0);
-	return line || "clpp";
+	let best: { bin: string; parsed: Semver } | null = null;
+	let fallback: string | null = null;
+	for (const bin of candidates) {
+		const version = probeVersion(bin);
+		const parsed = parseSemver(version || "");
+		if (!fallback) {
+			fallback = bin;
+		}
+		if (!parsed) {
+			continue;
+		}
+		if (!best || cmpSemver(parsed, best.parsed) > 0) {
+			best = { bin, parsed };
+		}
+	}
+	return best?.bin || fallback;
+}
+
+function whichClpp(): string | null {
+	if (cachedBin !== undefined) {
+		return cachedBin;
+	}
+	cachedBin = pickClppBinary();
+	return cachedBin;
 }
 
 export function hasClpp(): boolean {
@@ -28,6 +133,11 @@ export function resolveClppBinary(): string {
 	if (!bin) {
 		throw new Error(MISSING_CLPP);
 	}
+	const version = probeVersion(bin);
+	const parsed = parseSemver(version || "");
+	if (!parsed || cmpSemver(parsed, minClpp()) < 0) {
+		throw new Error(tooOldMessage(bin, version));
+	}
 	return bin;
 }
 
@@ -55,12 +165,25 @@ function parseArtifact(stdout: string, fileName: string, fallbackError: string):
 	};
 }
 
+export function formatClppFailure(artifact: CompileArtifact, fallback: string): string {
+	const diags = Array.isArray(artifact.diagnostics) ? artifact.diagnostics : [];
+	if (diags.length > 0) {
+		return diags
+			.map((d: CompileDiagnostic) => {
+				const where = `${artifact.fileName || "clpp"}:${d.line}:${d.column}`;
+				return `${where}: ${d.message}`;
+			})
+			.join("\n");
+	}
+	return artifact.error || fallback;
+}
+
 export function compileViaClpp(request: CompileRequest): CompileArtifact {
 	const bin = resolveClppBinary();
 	const payload = JSON.stringify({
 		source: request.source,
 		fileName: request.fileName,
-		strict: request.strict,
+		strict: request.strict ?? null,
 	});
 	const result = spawnSync(bin, ["api", "compile"], {
 		input: payload,
@@ -72,11 +195,53 @@ export function compileViaClpp(request: CompileRequest): CompileArtifact {
 	const stderr = String(result.stderr || "").trim();
 	const artifact = parseArtifact(result.stdout, request.fileName, stderr || result.error?.message || "clpp api compile failed");
 	if (!artifact.ok) {
-		throw new Error(artifact.error || stderr || `clpp failed (${result.status})`);
+		throw new Error(formatClppFailure(artifact, stderr || result.error?.message || `clpp failed (${result.status})`));
 	}
 	return artifact;
 }
 
+export function compileViaClppAsync(request: CompileRequest): Promise<CompileArtifact> {
+	return new Promise((resolve, reject) => {
+		let bin: string;
+		try {
+			bin = resolveClppBinary();
+		} catch (err) {
+			reject(err);
+			return;
+		}
+		const child = spawn(bin, ["api", "compile"], {
+			cwd: request.cwd,
+			windowsHide: true,
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk;
+		});
+		child.on("error", reject);
+		child.on("close", (code) => {
+			const artifact = parseArtifact(stdout, request.fileName, stderr.trim() || `clpp api compile failed (${code})`);
+			if (!artifact.ok) {
+				reject(new Error(formatClppFailure(artifact, stderr.trim() || `clpp failed (${code})`)));
+				return;
+			}
+			resolve(artifact);
+		});
+		child.stdin.end(
+			JSON.stringify({
+				source: request.source,
+				fileName: request.fileName,
+				strict: request.strict ?? null,
+			}),
+		);
+	});
+}
+
 export function clppManifest(): LanguageManifest {
 	const bin = resolveClppBinary();
 	const result = spawnSync(bin, ["api", "manifest"], {
@@ -94,9 +259,14 @@ export function clppVersion(): string | null {
 	if (!bin) {
 		return null;
 	}
-	const result = spawnSync(bin, ["--version"], { encoding: "utf8", windowsHide: true });
-	if (result.status !== 0) {
-		return null;
-	}
-	return String(result.stdout || "").trim() || null;
+	return probeVersion(bin);
+}
+
+export function clppInstalls(): Array<{ bin: string; version: string | null; selected: boolean }> {
+	const selected = whichClpp();
+	return listClppCandidates().map((bin) => ({
+		bin,
+		version: probeVersion(bin),
+		selected: bin === selected,
+	}));
 }

package/src/compile.ts

@@ -1,25 +1,31 @@
 import path from "node:path";
 import type { CompileOptions, CompileServiceResult } from "./types.js";
-import { compileViaClpp } from "./clpp/runner.js";
+import { compileViaClpp, compileViaClppAsync } from "./clpp/runner.js";
 import { clppLuauToGame, shouldSkipInit } from "./clpp/postprocess.js";
 import { emitKind, siblingHeader, toLuauPath } from "./clpp/paths.js";
+import type { CompileArtifact } from "./clpp/contract.js";
 
-export function compileSource(source: string, fileName?: string, options: CompileOptions = {}): string {
-	return compileService(source, fileName, options).files[0]?.contents ?? "";
-}
-
-export function compileService(source: string, fileName?: string, options: CompileOptions = {}): CompileServiceResult {
+function compileArgs(source: string, fileName: string | undefined, options: CompileOptions) {
 	const relative = (options.relativeName || fileName || "input.clpp").replace(/\\/g, "/");
 	const outName = options.outName || toLuauPath(relative);
 	const header = options.filePath ? siblingHeader(options.filePath) : null;
 	const skipInit = options.skipInit === true || shouldSkipInit(relative, Boolean(header));
 	const diskPath = options.filePath ? path.resolve(options.filePath) : null;
-	const artifact = compileViaClpp({
-		source,
-		fileName: diskPath ? diskPath.replace(/\\/g, "/") : relative,
-		strict: options.strict,
-		cwd: diskPath ? path.dirname(diskPath) : options.srcDir,
-	});
+	return {
+		request: {
+			source,
+			fileName: diskPath ? diskPath.replace(/\\/g, "/") : relative,
+			strict: options.strict,
+			cwd: diskPath ? path.dirname(diskPath) : options.srcDir,
+		},
+		relative,
+		outName,
+		skipInit,
+		options,
+	};
+}
+
+function finishArtifact(artifact: CompileArtifact, relative: string, outName: string, options: CompileOptions, skipInit: boolean): CompileServiceResult {
 	const luau = clppLuauToGame(artifact, {
 		relativeName: relative,
 		outName,
@@ -35,3 +41,19 @@ export function compileService(source: string, fileName?: string, options: Compi
 		stale: [],
 	};
 }
+
+export function compileSource(source: string, fileName?: string, options: CompileOptions = {}): string {
+	return compileService(source, fileName, options).files[0]?.contents ?? "";
+}
+
+export function compileService(source: string, fileName?: string, options: CompileOptions = {}): CompileServiceResult {
+	const args = compileArgs(source, fileName, options);
+	const artifact = compileViaClpp(args.request);
+	return finishArtifact(artifact, args.relative, args.outName, args.options, args.skipInit);
+}
+
+export async function compileServiceAsync(source: string, fileName?: string, options: CompileOptions = {}): Promise<CompileServiceResult> {
+	const args = compileArgs(source, fileName, options);
+	const artifact = await compileViaClppAsync(args.request);
+	return finishArtifact(artifact, args.relative, args.outName, args.options, args.skipInit);
+}

package/src/intellisense.ts

@@ -5,7 +5,7 @@ import { spawnSync } from "node:child_process";
 import { pkg, projectRoot as PACKAGE_ROOT } from "./package-info.js";
 import type { ProjectConfig } from "./types.js";
 import { CLPP_INSTALL_HINT } from "./clpp/contract.js";
-import { compileViaClpp, hasClpp } from "./clpp/runner.js";
+import { hasClpp } from "./clpp/runner.js";
 import { isSourceFile } from "./clpp/paths.js";
 
 export type CluauppDiagnostic = {
@@ -97,21 +97,10 @@ function writeVscode(root: string): void {
 	});
 }
 
-export function diagnosticsFor(source: string, fileName?: string): CluauppDiagnostic[] {
-	if (!hasClpp()) {
-		return [];
-	}
-	try {
-		compileViaClpp({ source, fileName: fileName || "input.clpp" });
-		return [];
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		const match = message.match(/:(\d+):(\d+):\s*(.*)$/);
-		if (match) {
-			return [{ line: Number(match[1]), col: Number(match[2]), message: match[3], severity: "error" }];
-		}
-		return [{ line: 1, col: 1, message, severity: "error" }];
-	}
+export function diagnosticsFor(_source?: string, _fileName?: string): CluauppDiagnostic[] {
+	// Language diagnostics belong to `clpp install`. Do not spawn `clpp api compile`
+	// from the editor — that duplicates source=clpp and freezes on every keystroke.
+	return [];
 }
 
 export function syncEditorSupport(root: string, _config: Partial<ProjectConfig> = {}): void {

package/src/lsp.ts

@@ -5,19 +5,9 @@ import {
 	TextDocumentSyncKind,
 } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
-import { diagnosticsFor } from "./intellisense.js";
 import { pkg } from "./package-info.js";
 
-function uriPath(uri: string): string {
-	let file = String(uri || "").replace(/^file:\/\//, "");
-	if (/^\/[A-Za-z]:/.test(file)) {
-		file = file.slice(1);
-	}
-	return decodeURIComponent(file);
-}
-
-export function start(options: { projectRoot?: string } = {}): void {
-	const projectRoot = options.projectRoot || process.cwd();
+export function start(_options: { projectRoot?: string } = {}): void {
 	const connection = createConnection(ProposedFeatures.all);
 	const documents = new TextDocuments(TextDocument);
 
@@ -28,28 +18,13 @@ export function start(options: { projectRoot?: string } = {}): void {
 		serverInfo: { name: "cluaupp", version: pkg.version },
 	}));
 
-	const publish = (document: TextDocument) => {
-		const file = uriPath(document.uri);
-		const items = diagnosticsFor(document.getText(), file);
-		connection.sendDiagnostics({
-			uri: document.uri,
-			diagnostics: items.map((item) => ({
-				range: {
-					start: { line: Math.max(0, (item.line || 1) - 1), character: Math.max(0, (item.col || 1) - 1) },
-					end: { line: Math.max(0, (item.line || 1) - 1), character: Math.max(1, item.col || 1) },
-				},
-				severity: 1,
-				source: "cluaupp",
-				message: item.message,
-			})),
-		});
+	const clear = (uri: string) => {
+		connection.sendDiagnostics({ uri, diagnostics: [] });
 	};
 
-	documents.onDidOpen((event) => publish(event.document));
-	documents.onDidChangeContent((event) => publish(event.document));
-	documents.onDidClose((event) => {
-		connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
-	});
+	documents.onDidOpen((event) => clear(event.document.uri));
+	documents.onDidChangeContent((event) => clear(event.document.uri));
+	documents.onDidClose((event) => clear(event.document.uri));
 
 	documents.listen(connection);
 	connection.listen();

package/src/transpile.ts

@@ -1,6 +1,6 @@
 import path from "node:path";
 import type { CompileOptions, CompileServiceResult } from "./types.js";
-import { compileService } from "./compile.js";
+import { compileService, compileServiceAsync } from "./compile.js";
 import type { RojoMapper } from "./utils/rojo-mapper.js";
 
 export function transpileSource(
@@ -12,6 +12,15 @@ export function transpileSource(
 	return compileService(source, fileName, options);
 }
 
+export function transpileSourceAsync(
+	source: string,
+	fileName: string,
+	options: CompileOptions,
+	_mapper?: RojoMapper,
+): Promise<CompileServiceResult> {
+	return compileServiceAsync(source, fileName, options);
+}
+
 export function outputNameFor(inputFile: string, outputPath: string): string {
 	if (/\.luau$/i.test(outputPath)) {
 		return outputPath;

package/src/types.ts

@@ -53,6 +53,7 @@ export interface BuildOptions {
 	format?: boolean;
 	analyze?: boolean;
 	rojo?: string;
+	strict?: boolean;
 }
 
 export interface BuildResult {

package/src/utils/project.ts

@@ -6,7 +6,7 @@ import { collectSources, toLuauPath } from "../clpp/paths.js";
 import { syncEditorSupport } from "../intellisense.js";
 import { ProcessOrchestrator } from "./process-orchestrator.js";
 import { RojoMapper } from "./rojo-mapper.js";
-import { transpileSource } from "../transpile.js";
+import { transpileSource, transpileSourceAsync } from "../transpile.js";
 import { assertInitDest, assertInside, isInside, safeProjectSubdir, safeRelPath } from "./safe-paths.js";
 
 function readProjectConfig(file: string): Partial<ProjectConfig> {
@@ -245,6 +245,20 @@ function createMapper(root: string, config: ProjectConfig, rojoPath?: string): R
 	return mapper;
 }
 
+function compileOptions(root: string, config: ProjectConfig, file: string, rel: string) {
+	const srcDir = path.join(root, config.rootDir);
+	return {
+		...config,
+		filePath: file,
+		relativeName: rel,
+		outName: toLuauPath(rel),
+		architecture: config.architecture === true,
+		includeDirs: [path.dirname(file), srcDir, path.join(root, "include")],
+		srcDir,
+		outDir: config.outDir,
+	};
+}
+
 function compileProject(root: string, config: ProjectConfig, mapper: RojoMapper) {
 	const srcDir = path.join(root, config.rootDir);
 	const files = collectSources(srcDir);
@@ -255,16 +269,27 @@ function compileProject(root: string, config: ProjectConfig, mapper: RojoMapper)
 		const source = fs.readFileSync(file, "utf8");
 		const rel = posixRel(srcDir, file);
 		try {
-			const result = transpileSource(source, rel, {
-				...config,
-				filePath: file,
-				relativeName: rel,
-				outName: toLuauPath(rel),
-				architecture: config.architecture === true,
-				includeDirs: [path.dirname(file), srcDir, path.join(root, "include")],
-				srcDir,
-				outDir: config.outDir,
-			}, mapper);
+			const result = transpileSource(source, rel, compileOptions(root, config, file, rel), mapper);
+			jobs.push({ rel, files: result.files, stale: result.stale || [] });
+		} catch (err) {
+			errors.push({ rel, prefixes: sourcePrefixes(rel), message: (err as Error).message });
+		}
+	}
+
+	return { files, jobs, errors };
+}
+
+async function compileProjectAsync(root: string, config: ProjectConfig, mapper: RojoMapper) {
+	const srcDir = path.join(root, config.rootDir);
+	const files = collectSources(srcDir);
+	const jobs: Array<{ rel: string; files: Array<{ name: string; contents: string }>; stale: string[] }> = [];
+	const errors: Array<{ rel: string; prefixes: string[]; message: string }> = [];
+
+	for (const file of files) {
+		const source = fs.readFileSync(file, "utf8");
+		const rel = posixRel(srcDir, file);
+		try {
+			const result = await transpileSourceAsync(source, rel, compileOptions(root, config, file, rel), mapper);
 			jobs.push({ rel, files: result.files, stale: result.stale || [] });
 		} catch (err) {
 			errors.push({ rel, prefixes: sourcePrefixes(rel), message: (err as Error).message });
@@ -332,28 +357,15 @@ function ensureVendor(root: string): void {
 	copyHeaders(root);
 }
 
-export function build(root: string, options: BuildOptions = {}): BuildResult {
+function finishBuild(
+	root: string,
+	config: ProjectConfig,
+	compiled: { jobs: Array<{ rel: string; files: Array<{ name: string; contents: string }>; stale: string[] }>; errors: Array<{ rel: string; prefixes: string[]; message: string }> },
+	options: BuildOptions,
+): BuildResult {
 	const exitOnError = options.exitOnError !== false;
 	const holdOnError = options.holdOnError === true;
 	const format = options.format === true;
-	const config = loadConfig(root);
-	if (options.syncVendor !== false) {
-		ensureVendor(root);
-	}
-	const srcDir = path.join(root, config.rootDir);
-	if (!fs.existsSync(srcDir) || collectSources(srcDir).length === 0) {
-		console.error("no .clpp/.clp/.clh files in", config.rootDir);
-		if (!holdOnError) {
-			pruneOut(root, config, new Set(), []);
-		}
-		if (exitOnError) {
-			process.exit(1);
-		}
-		return { failed: 0, written: new Set() };
-	}
-
-	const mapper = createMapper(root, config, options.rojo);
-	const compiled = compileProject(root, config, mapper);
 	if (compiled.errors.length > 0) {
 		for (const err of compiled.errors) {
 			console.error(err.message);
@@ -395,6 +407,48 @@ export function build(root: string, options: BuildOptions = {}): BuildResult {
 	return { failed: compiled.errors.length, written };
 }
 
+function prepareBuild(root: string, options: BuildOptions) {
+	const exitOnError = options.exitOnError !== false;
+	const holdOnError = options.holdOnError === true;
+	const config = loadConfig(root);
+	if (options.strict === true) {
+		config.strict = true;
+	}
+	if (options.syncVendor !== false) {
+		ensureVendor(root);
+	}
+	const srcDir = path.join(root, config.rootDir);
+	if (!fs.existsSync(srcDir) || collectSources(srcDir).length === 0) {
+		console.error("no .clpp/.clp/.clh files in", config.rootDir);
+		if (!holdOnError) {
+			pruneOut(root, config, new Set(), []);
+		}
+		if (exitOnError) {
+			process.exit(1);
+		}
+		return null;
+	}
+	return { config, mapper: createMapper(root, config, options.rojo) };
+}
+
+export function build(root: string, options: BuildOptions = {}): BuildResult {
+	const prepared = prepareBuild(root, options);
+	if (!prepared) {
+		return { failed: 0, written: new Set() };
+	}
+	const compiled = compileProject(root, prepared.config, prepared.mapper);
+	return finishBuild(root, prepared.config, compiled, options);
+}
+
+export async function buildAsync(root: string, options: BuildOptions = {}): Promise<BuildResult> {
+	const prepared = prepareBuild(root, options);
+	if (!prepared) {
+		return { failed: 0, written: new Set() };
+	}
+	const compiled = await compileProjectAsync(root, prepared.config, prepared.mapper);
+	return finishBuild(root, prepared.config, compiled, options);
+}
+
 export async function init(dest: string): Promise<void> {
 	const target = assertInitDest(dest);
 	const template = path.join(__dirname, "..", "..", "templates", "game");
@@ -451,7 +505,6 @@ function acquireWatchLock(root: string): void {
 
 export function watch(root: string, options: BuildOptions = {}): void {
 	acquireWatchLock(root);
-	build(root, { exitOnError: false, syncVendor: false, holdOnError: true, format: options.format, rojo: options.rojo });
 	const config = loadConfig(root);
 	const dir = path.join(root, config.rootDir);
 	let timer: NodeJS.Timeout | null = null;
@@ -464,23 +517,24 @@ export function watch(root: string, options: BuildOptions = {}): void {
 			return;
 		}
 		running = true;
-		try {
-			build(root, { exitOnError: false, syncVendor: false, holdOnError: true, format: options.format, rojo: options.rojo });
-		} catch (err) {
-			console.error((err as Error).message);
-		} finally {
-			running = false;
-			if (queued) {
-				queued = false;
-				run();
-			}
-		}
+		void buildAsync(root, { exitOnError: false, syncVendor: false, holdOnError: true, format: options.format, rojo: options.rojo })
+			.catch((err) => {
+				console.error((err as Error).message);
+			})
+			.finally(() => {
+				running = false;
+				if (queued) {
+					queued = false;
+					run();
+				}
+			});
 	};
 
 	console.log("cluaupp", pkg.version, "watching", dir, "(libs untouched)");
 	if (!fs.existsSync(dir)) {
 		fs.mkdirSync(dir, { recursive: true });
 	}
+	run();
 	fs.watch(dir, { recursive: true }, () => {
 		if (timer) {
 			clearTimeout(timer);

package/templates/game/.vscode/extensions.json

@@ -1,5 +1,6 @@
 {
 	"unwantedRecommendations": [
 		"ms-vscode.cpptools"
-	]
+	],
+	"recommendations": []
 }