cluaupp 0.1.2 → 0.1.5

package/src/cli.js

@@ -3,7 +3,8 @@
 const fs = require("fs");
 const path = require("path");
 const { compileService } = require("./compile");
-const { isSourceFile, isHeaderFile, toLuauPath } = require("./preprocess");
+const { isSourceFile, toLuauPath } = require("./preprocess");
+const { syncEditorSupport, installEditorSupport } = require("./intellisense");
 const pkg = require("../package.json");
 
 function printHelp() {
@@ -11,8 +12,10 @@ function printHelp() {
 
 Usage:
   cluaupp init [folder]    create a game (src/server, src/client, src/shared)
-  cluaupp build [folder]   transpile src → out (PascalCase services)
+  cluaupp build [folder]   transpile src → out (one file per .cpp)
   cluaupp watch [folder]   rebuild on save
+  cluaupp lsp [folder]     language server (stdio JSON-RPC)
+  cluaupp intellisense     install Cursor/VS Code IntelliSense
   cluaupp --version        print version
   cluaupp --help           this help
 
@@ -107,10 +110,10 @@ function loadConfig(root) {
 	for (const name of configNames) {
 		const file = path.join(root, name);
 		if (fs.existsSync(file)) {
-			return { rootDir: "src", outDir: "out", strict: true, ...JSON.parse(fs.readFileSync(file, "utf8")) };
+			return { rootDir: "src", outDir: "out", strict: false, architecture: false, ...JSON.parse(fs.readFileSync(file, "utf8")) };
 		}
 	}
-	return { rootDir: "src", outDir: "out", strict: true };
+	return { rootDir: "src", outDir: "out", strict: false, architecture: false };
 }
 
 function collectCpp(dir, files = []) {
@@ -143,10 +146,6 @@ function collectFiles(dir, files = []) {
 	return files;
 }
 
-function siblingCpp(file) {
-	return file.replace(/\.(h|hpp|hh)$/i, ".cpp");
-}
-
 function resolveKey(file) {
 	const resolved = path.resolve(file);
 	return process.platform === "win32" ? resolved.toLowerCase() : resolved;
@@ -220,14 +219,10 @@ function pruneOut(root, config, written, failedPrefixes) {
 function compileProject(root, config) {
 	const srcDir = path.join(root, config.rootDir);
 	const files = collectCpp(srcDir);
-	const fileSet = new Set(files.map((file) => path.resolve(file)));
 	const jobs = [];
 	const errors = [];
 
 	for (const file of files) {
-		if (isHeaderFile(file) && fileSet.has(path.resolve(siblingCpp(file)))) {
-			continue;
-		}
 		const source = fs.readFileSync(file, "utf8");
 		const rel = posixRel(srcDir, file);
 		try {
@@ -236,8 +231,9 @@ function compileProject(root, config) {
 				filePath: file,
 				relativeName: rel,
 				outName: toLuauPath(rel),
-				architecture: config.architecture !== false,
+				architecture: config.architecture === true,
 				includeDirs: [path.dirname(file), srcDir, path.join(root, "include")],
+				srcDir,
 			});
 			jobs.push({ rel, files: result.files, stale: result.stale || [] });
 		} catch (err) {
@@ -293,12 +289,8 @@ function ensureVendor(root) {
 function build(root, options = {}) {
 	const exitOnError = options.exitOnError !== false;
 	const holdOnError = options.holdOnError === true;
-	const syncVendor = options.syncVendor === true;
 	const config = loadConfig(root);
-	if (syncVendor) {
-		copyRuntime(root);
-		copyHeaders(root);
-	} else {
+	if (options.syncVendor !== false) {
 		ensureVendor(root);
 	}
 	const srcDir = path.join(root, config.rootDir);
@@ -320,6 +312,11 @@ function build(root, options = {}) {
 		}
 		if (holdOnError) {
 			console.error(`cluaupp: out not updated (${compiled.errors.length} compile error${compiled.errors.length === 1 ? "" : "s"})`);
+			try {
+				syncEditorSupport(root, config);
+			} catch (err) {
+				console.error("cluaupp: intellisense sync failed", err.message);
+			}
 			return { failed: compiled.errors.length, written: new Set() };
 		}
 	}
@@ -327,24 +324,74 @@ function build(root, options = {}) {
 	const written = writeJobs(root, config, compiled.jobs);
 	const failedPrefixes = compiled.errors.flatMap((err) => err.prefixes);
 	pruneOut(root, config, written, failedPrefixes);
+	try {
+		syncEditorSupport(root, config);
+	} catch (err) {
+		console.error("cluaupp: intellisense sync failed", err.message);
+	}
 	if (compiled.errors.length > 0 && exitOnError) {
 		process.exit(1);
 	}
 	return { failed: compiled.errors.length, written };
 }
 
-function init(dest) {
+async function init(dest) {
 	const template = path.join(__dirname, "..", "templates", "game");
 	const include = path.join(__dirname, "..", "include");
 	copyDir(template, dest);
 	copyDir(include, path.join(dest, "include"));
 	copyRuntime(dest);
+	syncEditorSupport(dest);
+	const installed = await installEditorSupport();
 	console.log("Cluaupp ready in", dest);
 	console.log("  cluaupp build");
 	console.log("  rojo serve");
+	if (installed.local.length || (installed.cpp && installed.cpp.status === "installed")) {
+		console.log("  reload Cursor (Ctrl+Shift+P → Developer: Reload Window)");
+	}
+}
+
+function pidAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function acquireWatchLock(root) {
+	const file = path.join(root, ".cluaupp-watch.lock");
+	if (fs.existsSync(file)) {
+		const pid = Number(fs.readFileSync(file, "utf8").trim());
+		if (Number.isFinite(pid) && pid !== process.pid && pidAlive(pid)) {
+			console.error(`cluaupp: watch already running (pid ${pid}). Stop it first — two watchers make Rojo crash on libs/.`);
+			process.exit(1);
+		}
+	}
+	fs.writeFileSync(file, String(process.pid), "utf8");
+	const release = () => {
+		try {
+			if (fs.existsSync(file) && fs.readFileSync(file, "utf8").trim() === String(process.pid)) {
+				fs.unlinkSync(file);
+			}
+		} catch {
+			// ignore
+		}
+	};
+	process.on("exit", release);
+	process.on("SIGINT", () => {
+		release();
+		process.exit(0);
+	});
+	process.on("SIGTERM", () => {
+		release();
+		process.exit(0);
+	});
 }
 
 function watch(root) {
+	acquireWatchLock(root);
 	build(root, { exitOnError: false, syncVendor: false, holdOnError: true });
 	const config = loadConfig(root);
 	const dir = path.join(root, config.rootDir);
@@ -371,7 +418,7 @@ function watch(root) {
 		}
 	};
 
-	console.log("watching", dir);
+	console.log("cluaupp", pkg.version, "watching", dir, "(libs untouched)");
 	if (!fs.existsSync(dir)) {
 		fs.mkdirSync(dir, { recursive: true });
 	}
@@ -385,11 +432,31 @@ function dispatch(args) {
 	const cmd = args[0] || "help";
 	const cwd = process.cwd();
 	if (cmd === "init") {
-		init(path.resolve(cwd, args[1] || "."));
+		return init(path.resolve(cwd, args[1] || ".")).catch((err) => {
+			console.error(err.message || err);
+			process.exit(1);
+		});
 	} else if (cmd === "build") {
 		build(path.resolve(cwd, args[1] || "."));
 	} else if (cmd === "watch") {
 		watch(path.resolve(cwd, args[1] || "."));
+	} else if (cmd === "lsp") {
+		const { start } = require("./lsp");
+		start({ projectRoot: path.resolve(cwd, args[1] || ".") });
+	} else if (cmd === "intellisense" || cmd === "intelisense") {
+		const root = path.resolve(cwd, args[1] || ".");
+		syncEditorSupport(root, loadConfig(root));
+		return installEditorSupport().then((installed) => {
+			console.log("cluaupp: compile_commands.json, .clangd, and .vscode updated in", root);
+			if (installed.local.length) {
+				for (const dest of installed.local) {
+					console.log("cluaupp: Cluaupp IntelliSense", dest);
+				}
+			}
+		}).catch((err) => {
+			console.error(err.message || err);
+			process.exit(1);
+		});
 	} else if (cmd === "--version" || cmd === "-v" || cmd === "version") {
 		console.log(pkg.version);
 	} else {

package/src/client/init.client.cpp

@@ -0,0 +1,5 @@
+#include <cluaupp/roblox.hpp>
+
+void init() {
+	print("Cluaupp client ok");
+}

package/src/compile.js

@@ -1,30 +1,100 @@
 "use strict";
 
+const path = require("path");
 const { parse } = require("./parse");
 const { emit } = require("./emit");
-const { preprocess } = require("./preprocess");
-const { collectLibraries, insertRequires } = require("./libs");
+const { preprocess, isHeaderFile, toLuauPath, siblingImplementation, siblingHeader, implOutName } = require("./preprocess");
+const { collectLibraries, insertPreamble } = require("./libs");
 const { planOutput } = require("./architecture");
+const { emitHeaderModule, primaryHeaderName } = require("./headers");
+
+function shouldAttachRequires(name) {
+	return !/\.(json)$/i.test(String(name || ""));
+}
+
+function attachRequires(contents, source, ast, options, outName) {
+	if (!shouldAttachRequires(outName)) {
+		return contents;
+	}
+	const libraries = String(contents).includes("CluauppLibs") ? [] : collectLibraries(source, ast);
+	return insertPreamble(contents, options.moduleIncludes || [], libraries, outName);
+}
+
+function posixRel(from, file) {
+	return path.relative(from, file).replace(/\\/g, "/");
+}
+
+function wireHeaderImpl(ast, fileName, options) {
+	const headerPath = options.filePath || null;
+	const impl = headerPath ? siblingImplementation(headerPath) : null;
+	if (!impl) {
+		return;
+	}
+	const typeName = primaryHeaderName(ast, options.relativeName || fileName);
+	const implRel = options.srcDir ? posixRel(options.srcDir, impl) : path.basename(impl).replace(/\\/g, "/");
+	const implOut = implOutName(implRel);
+	options.headerImplName = `${typeName}Module`;
+	options.moduleIncludes = options.moduleIncludes || [];
+	if (!options.moduleIncludes.some((spec) => spec.name === options.headerImplName)) {
+		options.moduleIncludes.push({
+			name: options.headerImplName,
+			outRel: implOut,
+			exports: { consts: [], structs: [] },
+		});
+	}
+}
+
+function compileHeader(source, fileName, options, prepared, ast) {
+	wireHeaderImpl(ast, fileName, options);
+	const rel = (options.relativeName || fileName || "header.h").replace(/\\/g, "/");
+	const outName = toLuauPath(rel);
+	const luau = attachRequires(emitHeaderModule(ast, options), source, ast, options, outName);
+	return {
+		kind: "module",
+		plan: { kind: "module", strict: options.strict === true },
+		files: [{ name: outName, contents: luau }],
+		stale: [],
+	};
+}
 
 function compileSource(source, fileName, options = {}) {
-	const prepared = options.filePath ? preprocess(source, options.filePath, options) : source;
+	options.moduleIncludes = options.moduleIncludes || [];
+	const prepared = preprocess(source, options.filePath || null, options);
 	const ast = parse(prepared, fileName || "input.cpp");
+	if (isHeaderFile(fileName) || isHeaderFile(options.filePath || "")) {
+		return compileHeader(source, fileName, options, prepared, ast).files[0].contents;
+	}
 	const luau = emit(ast, options);
-	return insertRequires(luau, collectLibraries(source, ast));
+	return attachRequires(luau, source, ast, options, options.outName || fileName);
 }
 
 function compileService(source, fileName, options = {}) {
-	const prepared = options.filePath ? preprocess(source, options.filePath, options) : source;
+	options.moduleIncludes = options.moduleIncludes || [];
+	const prepared = preprocess(source, options.filePath || null, options);
 	const ast = parse(prepared, fileName || "input.cpp");
+	if (isHeaderFile(fileName) || isHeaderFile(options.filePath || "") || isHeaderFile(options.relativeName || "")) {
+		return compileHeader(source, fileName, options, prepared, ast);
+	}
+	const implHeader = options.filePath ? siblingHeader(options.filePath) : null;
+	if (implHeader) {
+		options.skipInit = true;
+	}
 	const planned = planOutput(ast, fileName || "input.cpp", {
 		...options,
 		relativeName: options.relativeName || fileName,
 		source: prepared,
+		siblingHeader: implHeader,
 	});
 	if (planned.files) {
-		return planned;
+		return {
+			...planned,
+			files: planned.files.map((file) => ({
+				...file,
+				contents: attachRequires(file.contents, source, ast, options, file.name),
+			})),
+		};
 	}
-	const luau = insertRequires(emit(ast, options), collectLibraries(source, ast));
+	const luau = attachRequires(emit(ast, options), source, ast, options, planned.outName || options.outName || fileName);
 	const name =
 		planned.outName ||
 		options.outName ||

package/src/editor-install.js

@@ -0,0 +1,218 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const https = require("https");
+const { spawnSync } = require("child_process");
+
+const CPPTOOLS_ID = "ms-vscode.cpptools";
+const GITHUB_LATEST = "https://api.github.com/repos/microsoft/vscode-cpptools/releases/latest";
+
+function which(command) {
+	const finder = process.platform === "win32" ? "where" : "which";
+	const result = spawnSync(finder, [command], { encoding: "utf8", windowsHide: true });
+	if (result.status !== 0) {
+		return null;
+	}
+	return String(result.stdout || "")
+		.split(/\r?\n/)
+		.map((line) => line.trim())
+		.find((line) => line && !line.toLowerCase().includes("info:"));
+}
+
+function editorBin() {
+	const found = which("cursor") || which("code");
+	if (found) {
+		return found;
+	}
+	const local = process.env.LOCALAPPDATA || "";
+	const fallbacks = [
+		path.join(local, "Programs", "cursor", "resources", "app", "bin", "cursor.cmd"),
+		path.join(local, "Programs", "Microsoft VS Code", "bin", "code.cmd"),
+		"/usr/bin/cursor",
+		"/usr/local/bin/cursor",
+		"/usr/bin/code",
+		"/usr/local/bin/code",
+	];
+	return fallbacks.find((file) => fs.existsSync(file)) || null;
+}
+
+function extensionHomes() {
+	return [
+		path.join(os.homedir(), ".cursor", "extensions"),
+		path.join(os.homedir(), ".vscode", "extensions"),
+	];
+}
+
+function isCppToolsInstalled() {
+	for (const home of extensionHomes()) {
+		if (!fs.existsSync(home)) {
+			continue;
+		}
+		try {
+			if (fs.readdirSync(home).some((name) => name.startsWith(CPPTOOLS_ID + "-"))) {
+				return true;
+			}
+		} catch {
+			// ignore
+		}
+	}
+	const bin = editorBin();
+	if (!bin) {
+		return false;
+	}
+	const listed = spawnSync(bin, ["--list-extensions"], { encoding: "utf8", windowsHide: true, timeout: 20000 });
+	return String(listed.stdout || "").split(/\r?\n/).includes(CPPTOOLS_ID);
+}
+
+function vsixAssetName(platform = process.platform, arch = process.arch) {
+	const cpu = arch === "arm64" ? "arm64" : "x64";
+	if (platform === "win32") {
+		return `cpptools-windows-${cpu}.vsix`;
+	}
+	if (platform === "darwin") {
+		return `cpptools-macOS-${cpu}.vsix`;
+	}
+	return `cpptools-linux-${cpu}.vsix`;
+}
+
+function httpsJson(url) {
+	return new Promise((resolve, reject) => {
+		const request = https.get(
+			url,
+			{ headers: { "User-Agent": "cluaupp", Accept: "application/vnd.github+json" } },
+			(response) => {
+				if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+					response.resume();
+					httpsJson(response.headers.location).then(resolve, reject);
+					return;
+				}
+				const chunks = [];
+				response.on("data", (chunk) => chunks.push(chunk));
+				response.on("end", () => {
+					if (response.statusCode !== 200) {
+						reject(new Error("GitHub " + response.statusCode));
+						return;
+					}
+					try {
+						resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+					} catch (err) {
+						reject(err);
+					}
+				});
+			},
+		);
+		request.on("error", reject);
+	});
+}
+
+function downloadFile(url, dest) {
+	return new Promise((resolve, reject) => {
+		const follow = (current) => {
+			https
+				.get(current, { headers: { "User-Agent": "cluaupp" } }, (response) => {
+					if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+						response.resume();
+						follow(response.headers.location);
+						return;
+					}
+					if (response.statusCode !== 200) {
+						reject(new Error("download failed " + response.statusCode));
+						return;
+					}
+					const out = fs.createWriteStream(dest);
+					response.pipe(out);
+					out.on("finish", () => out.close(() => resolve(dest)));
+					out.on("error", reject);
+				})
+				.on("error", reject);
+		};
+		follow(url);
+	});
+}
+
+async function downloadCppToolsVsix() {
+	const name = vsixAssetName();
+	const dest = path.join(os.tmpdir(), name);
+	if (fs.existsSync(dest) && fs.statSync(dest).size > 1_000_000) {
+		return dest;
+	}
+	const release = await httpsJson(GITHUB_LATEST);
+	const asset = (release.assets || []).find((item) => item.name === name);
+	if (!asset || !asset.browser_download_url) {
+		throw new Error("no " + name + " in vscode-cpptools " + (release.tag_name || "latest"));
+	}
+	console.log("cluaupp: downloading", name, release.tag_name || "");
+	return downloadFile(asset.browser_download_url, dest);
+}
+
+function spawnInstall(bin, target) {
+	const result = spawnSync(bin, ["--install-extension", target, "--force"], {
+		encoding: "utf8",
+		windowsHide: true,
+		timeout: 180000,
+	});
+	return {
+		ok: result.status === 0 && !/not found/i.test(String(result.stderr || "") + String(result.stdout || "")),
+		stdout: String(result.stdout || ""),
+		stderr: String(result.stderr || ""),
+		status: result.status,
+	};
+}
+
+async function installCppTools() {
+	if (isCppToolsInstalled()) {
+		return { status: "already", id: CPPTOOLS_ID };
+	}
+	const bin = editorBin();
+	if (!bin) {
+		return { status: "missing-editor", id: CPPTOOLS_ID };
+	}
+	console.log("cluaupp: installing", CPPTOOLS_ID);
+	const marketplace = spawnInstall(bin, CPPTOOLS_ID);
+	if (marketplace.ok) {
+		return { status: "installed", id: CPPTOOLS_ID, how: "marketplace" };
+	}
+	try {
+		const vsix = await downloadCppToolsVsix();
+		const fromFile = spawnInstall(bin, vsix);
+		if (fromFile.ok) {
+			return { status: "installed", id: CPPTOOLS_ID, how: "vsix", file: vsix };
+		}
+		return { status: "failed", id: CPPTOOLS_ID, detail: fromFile.stderr || fromFile.stdout || marketplace.stderr };
+	} catch (err) {
+		return { status: "failed", id: CPPTOOLS_ID, detail: err.message };
+	}
+}
+
+function reportCppTools(result) {
+	if (!result) {
+		return;
+	}
+	if (result.status === "already") {
+		console.log("cluaupp: Microsoft C/C++ already installed");
+		return;
+	}
+	if (result.status === "installed") {
+		console.log("cluaupp: installed", CPPTOOLS_ID, result.how === "vsix" ? "(VSIX — Cursor marketplace does not list it)" : "");
+		console.log("cluaupp: reload the editor (Ctrl+Shift+P → Developer: Reload Window)");
+		return;
+	}
+	if (result.status === "missing-editor") {
+		console.error("cluaupp: Cursor/VS Code CLI not found. Install ms-vscode.cpptools from the VSIX at");
+		console.error("  https://github.com/microsoft/vscode-cpptools/releases");
+		return;
+	}
+	console.error("cluaupp: could not install", CPPTOOLS_ID + ":", result.detail || "unknown error");
+	console.error("  download https://github.com/microsoft/vscode-cpptools/releases and: cursor --install-extension cpptools-windows-x64.vsix");
+}
+
+module.exports = {
+	CPPTOOLS_ID,
+	editorBin,
+	isCppToolsInstalled,
+	vsixAssetName,
+	installCppTools,
+	reportCppTools,
+};