cluaupp 0.1.2 → 0.1.4

package/src/architecture.js

@@ -3,6 +3,7 @@
 const path = require("path");
 const { emit } = require("./emit");
 const { collectLibraries, insertRequires, requireCluauppLib } = require("./libs");
+const { organizeDecls, janitorNames, emitSection, joinBlocks, SECTION, ENTRY_FN } = require("./layout");
 const {
 	VALUE_CLASSES,
 	analyze,
@@ -27,9 +28,9 @@ function cluauppLib(name) {
 
 function emitTypes(plan) {
 	const lines = [header(plan).trimEnd(), ""];
-	lines.push('local ReplicatedStorage = game:GetService("ReplicatedStorage")');
-	lines.push(`local Occlude = ${cluauppLib("Occlude")}`);
-	lines.push(`local ArrayIndexer = ${cluauppLib("ArrayIndexer")}`);
+	lines.push('const ReplicatedStorage = game:GetService("ReplicatedStorage")');
+	lines.push(`const Occlude = ${cluauppLib("Occlude")}`);
+	lines.push(`const ArrayIndexer = ${cluauppLib("ArrayIndexer")}`);
 	lines.push("");
 
 	if (plan.stats.length > 0) {
@@ -60,6 +61,7 @@ function emitTypes(plan) {
 		manifest.push("		Get: (player: Player) -> PlayerCache?,");
 		manifest.push("		Ensure: (player: Player) -> PlayerCache,");
 		manifest.push("		Clear: (player: Player) -> (),");
+		manifest.push("		ClearAll: () -> (),");
 		manifest.push("	},");
 	}
 	if (plan.roles.players) {
@@ -100,23 +102,26 @@ function emitTypes(plan) {
 }
 
 function emitPlayersManager(plan) {
-	return `${header(plan)}
-local Players = game:GetService("Players")
-local ReplicatedStorage = game:GetService("ReplicatedStorage")
-local Janitor = ${cluauppLib("Janitor")}
-type Janitor = Janitor.Janitor
+	return `${header(plan).trimEnd()}
+
+const Players = game:GetService("Players")
+const ReplicatedStorage = game:GetService("ReplicatedStorage")
+const Janitor = ${cluauppLib("Janitor")}
 
+type Janitor = Janitor.Janitor
 export type PlayerHandler = (player: Player) -> ()
 
 local PlayersManager = {}
 local lifetime: Janitor? = nil
+local leaveHandler: PlayerHandler? = nil
 
 function PlayersManager.Start(onPlayer: PlayerHandler, onLeave: PlayerHandler?)
 	PlayersManager.Stop()
 	local janitor = Janitor.new()
 	lifetime = janitor
+	leaveHandler = onLeave
 
-	local function accept(player: Player)
+	const function accept(player: Player)
 		onPlayer(player)
 	end
 
@@ -134,6 +139,13 @@ function PlayersManager.Stop()
 	if lifetime == nil then
 		return
 	end
+	local onLeave = leaveHandler
+	leaveHandler = nil
+	if onLeave then
+		for _, player in Players:GetPlayers() do
+			onLeave(player)
+		end
+	end
 	lifetime:Cleanup()
 	lifetime = nil
 end
@@ -146,11 +158,11 @@ function emitCacheController(plan) {
 	const types = plan.typesName;
 	const folder = plan.folderName || "leaderstats";
 	const lines = [header(plan).trimEnd(), ""];
-	lines.push(`local Types = require(script.Parent.${types})`);
+	lines.push(`const Types = require(script.Parent.${types})`);
 	lines.push("");
-	lines.push(`local FOLDER_NAME = "${folder}"`);
-	lines.push("local cache: { [Player]: Types.PlayerCache } = {}");
+	lines.push(`const FOLDER_NAME = "${folder}"`);
 	lines.push("");
+	lines.push("local cache: { [Player]: Types.PlayerCache } = {}");
 	lines.push("local CacheController = {}");
 	lines.push("");
 	lines.push("function CacheController.Get(player: Player): Types.PlayerCache?");
@@ -201,6 +213,10 @@ function emitCacheController(plan) {
 	lines.push("	cache[player] = nil");
 	lines.push("end");
 	lines.push("");
+	lines.push("function CacheController.ClearAll()");
+	lines.push("	table.clear(cache)");
+	lines.push("end");
+	lines.push("");
 	lines.push("return CacheController");
 	lines.push("");
 	return lines.join("\n");
@@ -209,13 +225,13 @@ function emitCacheController(plan) {
 function emitMain(plan) {
 	const lines = [header(plan).trimEnd(), ""];
 	if (plan.roles.players) {
-		lines.push("local PlayersManager = require(script.Parent.PlayersManager)");
+		lines.push("const PlayersManager = require(script.Parent.PlayersManager)");
 	}
 	if (plan.roles.cache) {
-		lines.push("local CacheController = require(script.Parent.CacheController)");
+		lines.push("const CacheController = require(script.Parent.CacheController)");
 	}
 	if (plan.roles.domain) {
-		lines.push(`local ${plan.roles.domain} = require(script.Parent.${plan.roles.domain})`);
+		lines.push(`const ${plan.roles.domain} = require(script.Parent.${plan.roles.domain})`);
 	}
 	lines.push("");
 	lines.push("local Main = {}");
@@ -242,9 +258,15 @@ function emitMain(plan) {
 	if (plan.roles.domain) {
 		lines.push(`	${plan.roles.domain}.Stop()`);
 	}
+	if (plan.roles.cache) {
+		lines.push("	CacheController.ClearAll()");
+	}
 	if (plan.roles.players) {
 		lines.push("	PlayersManager.Stop()");
 	}
+	if (!plan.roles.domain && !plan.roles.cache && !plan.roles.players) {
+		lines.push("	return");
+	}
 	lines.push("end");
 	lines.push("");
 	lines.push("return Main");
@@ -258,6 +280,10 @@ function emitBootstrap(plan) {
 }
 
 function emitConfig(plan, ast, options) {
+	const owned = (ast.body || []).some((decl) => decl.owner);
+	if (owned) {
+		return `${header(plan).trimEnd()}\n\n${emit(ast, { ...options, skipHeader: true, skipInit: true }).trimEnd()}\n`;
+	}
 	const lines = [];
 	if (plan.onlyConsts) {
 		lines.push(header(plan).trimEnd());
@@ -282,48 +308,54 @@ function emitConfig(plan, ast, options) {
 	}
 	if ((ast.body || []).some((decl) => decl.type === "function" && decl.name === "init")) {
 		lines.push("	Start = init,");
+		lines.push("	Init = init,");
+		lines.push("	init = init,");
 	}
 	lines.push("}");
 	lines.push("");
 	return lines.join("\n");
 }
 
+function emitDecls(decls, options) {
+	if (!decls || decls.length === 0) {
+		return "";
+	}
+	return emit({ type: "program", body: decls }, { ...options, skipHeader: true, skipInit: true }).trimEnd();
+}
+
 function emitDomainController(plan, ast, options) {
-	const absorbCache = plan.roles.cache;
 	const keep = (ast.body || []).filter((decl) => {
-		if (decl.type === "decl" || decl.type === "proto") {
-			return true;
-		}
-		if (decl.type !== "function") {
-			return false;
-		}
-		if (decl.name === "init") {
-			return true;
-		}
-		const classified = plan.functions.find((item) => item.name === decl.name);
-		if (absorbCache && classified && classified.absorb === "cache") {
-			return false;
-		}
-		return true;
+		return decl.type === "decl" || decl.type === "proto" || decl.type === "function" || decl.type === "expr";
 	});
+	const groups = organizeDecls(keep);
 	const subset = { type: "program", body: keep };
-	const code = emit(subset, { ...options, skipHeader: true, skipInit: true }).trimEnd();
 	const name = plan.roles.domain;
 	const libs = collectLibraries(options.source || "", subset);
-	const body = `${header(plan)}${code}
-
-local ${name} = {}
-
-function ${name}.Start()
-	${keep.some((decl) => decl.type === "function" && decl.name === "init") ? "init()" : "return"}
-end
-
-function ${name}.Stop()
-	return
-end
-
-return ${name}
-`;
+	const entry = keep.find((decl) => decl.type === "function" && ENTRY_FN.test(decl.name || ""));
+	const bootExprs = keep.filter((decl) => decl.type === "expr");
+	const janitors = janitorNames(keep);
+	const closer = keep.find((decl) => decl.type === "function" && /^(OnClose|Cleanup|Shutdown)$/i.test(decl.name));
+	const stopLines = [];
+	if (janitors.length > 0) {
+		for (const janitor of janitors) {
+			stopLines.push(`	${janitor}:Cleanup()`);
+		}
+	} else if (closer) {
+		stopLines.push(`	${closer.name}()`);
+	} else {
+		stopLines.push("	return");
+	}
+	const boot = entry
+		? `	${entry.name}()`
+		: bootExprs.length
+			? emitDecls(bootExprs, options)
+					.split("\n")
+					.map((line) => (line ? `\t${line}` : line))
+					.join("\n")
+			: "	return";
+	const startFn = `function ${name}.Start()\n	${name}.Stop()\n${boot}\nend`;
+	const stopFn = `function ${name}.Stop()\n${stopLines.join("\n")}\nend`;
+	const body = `${header(plan).trimEnd()}\n\n${emitSection(SECTION.api, emitDecls(groups.api, options))}${emitSection(SECTION.constants, emitDecls(groups.constants, options))}${emitSection(SECTION.variables, joinBlocks([emitDecls(groups.variables, options), `local ${name} = {}`]))}${emitSection(SECTION.support, emitDecls(groups.support, options))}${emitSection(SECTION.principal, joinBlocks([emitDecls(groups.principal, options), startFn]))}${emitSection(SECTION.cleanup, joinBlocks([emitDecls(groups.cleanup, options), stopFn]))}${emitSection(SECTION.returns, `return ${name}`)}`;
 	return insertRequires(body, libs);
 }
 
@@ -331,10 +363,34 @@ function emitModule(plan, ast, options) {
 	return emitConfig(plan, ast, options);
 }
 
+function emitScriptMeta(runContext) {
+	return `${JSON.stringify(
+		{
+			className: "Script",
+			properties: {
+				RunContext: `Enum.RunContext.${runContext}`,
+			},
+		},
+		null,
+		"\t",
+	)}\n`;
+}
+
+function serviceBootName(plan) {
+	if (plan.isClient) {
+		return "init.client.luau";
+	}
+	return "init.luau";
+}
+
 function serviceFiles(plan, ast, options, dir) {
 	const folder = `${dir}/${plan.serviceName}`;
-	const boot = plan.isClient ? "init.client.luau" : "init.server.luau";
-	const files = [{ name: `${folder}/${boot}`, contents: emitBootstrap(plan) }, { name: `${folder}/Main.luau`, contents: emitMain(plan) }];
+	const boot = serviceBootName(plan);
+	const files = [{ name: `${folder}/${boot}`, contents: emitBootstrap(plan) }];
+	if (!plan.isClient && plan.runContext) {
+		files.push({ name: `${folder}/init.meta.json`, contents: emitScriptMeta(plan.runContext) });
+	}
+	files.push({ name: `${folder}/Main.luau`, contents: emitMain(plan) });
 	if (plan.roles.players) {
 		files.push({ name: `${folder}/PlayersManager.luau`, contents: emitPlayersManager(plan) });
 	}
@@ -365,11 +421,15 @@ function planOutput(ast, fileName, options = {}) {
 
 	if (plan.kind === "service") {
 		const serviceDir = outDir || (plan.isClient ? "client" : "server");
+		const folder = `${serviceDir}/${plan.serviceName}`;
+		const stale = plan.isClient
+			? [`${folder}/init.luau`, `${folder}/init.server.luau`, `${folder}/init.meta.json`]
+			: [`${folder}/init.server.luau`, `${folder}/init.client.luau`];
 		return {
 			kind: "service",
 			plan,
 			files: serviceFiles(plan, ast, options, serviceDir),
-			stale: [rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau")],
+			stale,
 		};
 	}
 

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, isHeaderFile, toLuauPath, siblingImplementation } = require("./preprocess");
+const { syncEditorSupport, installEditorSupport } = require("./intellisense");
 const pkg = require("../package.json");
 
 function printHelp() {
@@ -13,6 +14,8 @@ Usage:
   cluaupp init [folder]    create a game (src/server, src/client, src/shared)
   cluaupp build [folder]   transpile src → out (PascalCase services)
   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
 
@@ -144,7 +147,7 @@ function collectFiles(dir, files = []) {
 }
 
 function siblingCpp(file) {
-	return file.replace(/\.(h|hpp|hh)$/i, ".cpp");
+	return siblingImplementation(file) || file.replace(/\.(h|hpp|hh)$/i, ".cpp");
 }
 
 function resolveKey(file) {
@@ -238,6 +241,7 @@ function compileProject(root, config) {
 				outName: toLuauPath(rel),
 				architecture: config.architecture !== false,
 				includeDirs: [path.dirname(file), srcDir, path.join(root, "include")],
+				srcDir,
 			});
 			jobs.push({ rel, files: result.files, stale: result.stale || [] });
 		} catch (err) {
@@ -293,12 +297,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 +320,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 +332,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 +426,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 +440,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

@@ -3,17 +3,27 @@
 const { parse } = require("./parse");
 const { emit } = require("./emit");
 const { preprocess } = require("./preprocess");
-const { collectLibraries, insertRequires } = require("./libs");
+const { collectLibraries, insertRequires, insertModuleRequires } = require("./libs");
 const { planOutput } = require("./architecture");
 
+function attachRequires(contents, source, ast, options, outName) {
+	let next = contents;
+	if (!next.includes("CluauppLibs")) {
+		next = insertRequires(next, collectLibraries(source, ast));
+	}
+	return insertModuleRequires(next, options.moduleIncludes || [], outName);
+}
+
 function compileSource(source, fileName, options = {}) {
+	options.moduleIncludes = options.moduleIncludes || [];
 	const prepared = options.filePath ? preprocess(source, options.filePath, options) : source;
 	const ast = parse(prepared, fileName || "input.cpp");
 	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 = {}) {
+	options.moduleIncludes = options.moduleIncludes || [];
 	const prepared = options.filePath ? preprocess(source, options.filePath, options) : source;
 	const ast = parse(prepared, fileName || "input.cpp");
 	const planned = planOutput(ast, fileName || "input.cpp", {
@@ -22,9 +32,15 @@ function compileService(source, fileName, options = {}) {
 		source: prepared,
 	});
 	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 ||