cluaupp 0.1.5 → 0.2.0

package/generated/utils/safe-paths.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathEscapeError = void 0;
+exports.posixRel = posixRel;
+exports.isInside = isInside;
+exports.realPath = realPath;
+exports.assertInside = assertInside;
+exports.safeRelPath = safeRelPath;
+exports.safeProjectSubdir = safeProjectSubdir;
+exports.assertInitDest = assertInitDest;
+exports.childEnv = childEnv;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const BLOCKED_DIRS = new Set([".", "..", "node_modules", ".git"]);
+class PathEscapeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PathEscapeError";
+    }
+}
+exports.PathEscapeError = PathEscapeError;
+function posixRel(rel) {
+    return String(rel || "").replace(/\\/g, "/");
+}
+function isInside(root, target) {
+    const absRoot = node_path_1.default.resolve(root);
+    const absTarget = node_path_1.default.resolve(target);
+    const rel = node_path_1.default.relative(absRoot, absTarget);
+    return rel === "" || (!rel.startsWith("..") && !node_path_1.default.isAbsolute(rel));
+}
+function realPath(target) {
+    try {
+        return node_fs_1.default.realpathSync(target);
+    }
+    catch {
+        return node_path_1.default.resolve(target);
+    }
+}
+function assertInside(root, target, label) {
+    const absRoot = realPath(root);
+    const absTarget = node_path_1.default.resolve(target);
+    if (!isInside(absRoot, absTarget)) {
+        throw new PathEscapeError(`cluaupp: ${label} escapes the project folder`);
+    }
+    return absTarget;
+}
+function safeRelPath(rel) {
+    const normalized = posixRel(rel).replace(/^\.\/+/, "");
+    if (!normalized || node_path_1.default.isAbsolute(normalized) || /^[a-zA-Z]:/.test(normalized)) {
+        return null;
+    }
+    const parts = normalized.split("/").filter((part) => part && part !== ".");
+    if (parts.length === 0 || parts.some((part) => part === ".." || part === ".git")) {
+        return null;
+    }
+    return parts.join("/");
+}
+function safeProjectSubdir(value, fallback, label) {
+    const cleaned = safeRelPath(value);
+    if (!cleaned || BLOCKED_DIRS.has(cleaned.split("/")[0] || "")) {
+        throw new PathEscapeError(`cluaupp: invalid ${label} ${JSON.stringify(value)}`);
+    }
+    return cleaned;
+}
+function assertInitDest(dest) {
+    const resolved = node_path_1.default.resolve(dest);
+    const root = node_path_1.default.parse(resolved).root;
+    if (resolved === root) {
+        throw new PathEscapeError("cluaupp: refused to init at the filesystem root");
+    }
+    const home = node_os_1.default.homedir();
+    if (home && node_path_1.default.resolve(home) === resolved) {
+        throw new PathEscapeError("cluaupp: refused to init in the home directory itself");
+    }
+    return resolved;
+}
+function childEnv() {
+    const env = {};
+    for (const key of [
+        "PATH",
+        "Path",
+        "PATHEXT",
+        "SYSTEMROOT",
+        "SystemRoot",
+        "COMSPEC",
+        "ComSpec",
+        "HOME",
+        "USERPROFILE",
+        "TMP",
+        "TEMP",
+        "TMPDIR",
+        "LANG",
+        "LC_ALL",
+    ]) {
+        if (process.env[key]) {
+            env[key] = process.env[key];
+        }
+    }
+    return env;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cluaupp",
-	"version": "0.1.5",
+	"version": "0.2.0",
 	"description": "Cluaupp — the definitive merge of C++ and modern Luau. Source-to-source transpiler with first-class Roblox APIs.",
 	"author": "KartzDev",
 	"license": "MIT",
@@ -8,16 +8,18 @@
 		"cluaupp": "bin/cluaupp.js",
 		"cluau": "bin/cluaupp.js"
 	},
-	"main": "src/compile.js",
+	"main": "./generated/compile.js",
 	"exports": {
-		".": "./src/compile.js",
+		".": "./generated/compile.js",
 		"./package.json": "./package.json"
 	},
 	"files": [
 		"bin",
 		"src",
+		"generated",
 		"include",
 		"templates",
+		"examples",
 		"editors",
 		"runtime",
 		"README.md",
@@ -28,9 +30,11 @@
 	"scripts": {
 		"cluaupp": "node bin/cluaupp.js",
 		"cluau": "node bin/cluaupp.js",
-		"build": "node bin/cluaupp.js build",
-		"watch": "node bin/cluaupp.js watch",
-		"test": "node test/leaderstats.test.js && node test/understand.test.js && node test/datatypes.test.js && node test/headers.test.js && node test/libs.test.js && node test/runtime-libs.test.js && node test/intellisense.test.js && node test/intellisense-complete.test.js && node test/dataservice.test.js && node test/datacontroller-signal.test.js && node test/cout.test.js && node test/prune.test.js && node test/hold.test.js && node test/vendor-stable.test.js && node test/switch.test.js && node test/qualified.test.js && node test/module-require.test.js",
+		"build": "tsc",
+		"build:cli": "tsc",
+		"dev:cli": "tsx src/cli.ts",
+		"prepare": "tsc",
+		"test": "node test/out.test.js && node test/types.test.js && node test/modules.test.js && node test/security.test.js && node test/understander.test.js",
 		"generate-api": "node scripts/generate-api.js",
 		"check-highlight": "node scripts/check-highlight.js",
 		"vendor-libs": "node scripts/vendor-libs.js",
@@ -39,7 +43,7 @@
 		"site": "node scripts/generate-api.js && node scripts/check-highlight.js",
 		"dev": "node scripts/dev.js",
 		"stop": "node scripts/stop.js",
-		"prepublishOnly": "npm test"
+		"prepublishOnly": "tsc && npm test"
 	},
 	"engines": {
 		"node": ">=18"
@@ -62,5 +66,18 @@
 	"bugs": {
 		"url": "https://github.com/KartzRbx/Cluaupp/issues"
 	},
-	"homepage": "https://github.com/KartzRbx/Cluaupp#readme"
+	"homepage": "https://github.com/KartzRbx/Cluaupp#readme",
+	"dependencies": {
+		"commander": "^15.0.0",
+		"comment-json": "^5.0.0",
+		"tree-sitter": "^0.21.1",
+		"tree-sitter-cpp": "^0.23.4",
+		"vscode-languageserver": "^10.1.1",
+		"vscode-languageserver-textdocument": "^1.0.14"
+	},
+	"devDependencies": {
+		"@types/node": "^22.20.3",
+		"tsx": "^4.23.13",
+		"typescript": "^7.0.2"
+	}
 }

package/src/api.ts

@@ -0,0 +1,53 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+
+const projectRoot = path.resolve(__dirname, "..");
+const requireGenerated = createRequire(path.join(projectRoot, "src", "api.generated.js"));
+const generated = requireGenerated("./api.generated.js") as {
+	INSTANCE_TYPES: string[];
+	SERVICES: string[];
+	METHODS: string[];
+	DATATYPES: string[];
+};
+
+export const INSTANCE_TYPES = new Set(generated.INSTANCE_TYPES);
+export const SERVICES = new Set(generated.SERVICES);
+export const METHODS = new Set(generated.METHODS);
+export const DATATYPES = new Set(generated.DATATYPES);
+
+const LUAU_TYPES: Record<string, string | null> = {
+	void: "()",
+	int: "number",
+	float: "number",
+	double: "number",
+	bool: "boolean",
+	string: "string",
+	auto: null,
+};
+
+export function isInstanceType(name: string): boolean {
+	return INSTANCE_TYPES.has(name);
+}
+
+export function isService(name: string): boolean {
+	return SERVICES.has(name);
+}
+
+export function isMethod(name: string): boolean {
+	return METHODS.has(name);
+}
+
+export function isDatatype(name: string): boolean {
+	return DATATYPES.has(name);
+}
+
+export function luauType(name: string | null | undefined): string | null {
+	if (!name) {
+		return null;
+	}
+	const cleaned = String(name).replace(/\*+$/, "").replace(/^const\s+/, "").replace(/^Enum::/, "Enum.");
+	if (cleaned in LUAU_TYPES) {
+		return LUAU_TYPES[cleaned];
+	}
+	return cleaned;
+}

package/src/{architecture.js → architecture.ts}

@@ -1,17 +1,16 @@
-"use strict";
-
-const path = require("path");
-const { emit } = require("./emit");
-const { requireCluauppLib } = require("./libs");
-const { organizeDecls, janitorNames, emitSection, joinBlocks, SECTION, ENTRY_FN } = require("./layout");
-const {
+// @ts-nocheck
+import path from "node:path";
+import { emit } from "./emit.js";
+import { requireCluauppLib } from "./libs.js";
+import { organizeDecls, janitorNames, emitSection, joinBlocks, SECTION, ENTRY_FN } from "./layout.js";
+import {
 	VALUE_CLASSES,
 	analyze,
 	toPascalServiceName,
 	legacyOutName,
 	modernScriptOutName,
-} = require("./understand");
-const { implOutName } = require("./preprocess");
+} from "./understand.js";
+import { implOutName } from "./preprocess.js";
 
 function header(plan) {
 	const lines = [];
@@ -493,7 +492,7 @@ function planOutput(ast, fileName, options = {}) {
 	return { kind: "flat", plan, files: null, stale: [...stale, ...extraStale], outName };
 }
 
-module.exports = {
+export {
 	analyze,
 	planOutput,
 	toPascalServiceName,

package/src/ast.ts

@@ -0,0 +1,37 @@
+import type { CompileOptions } from "./types.js";
+
+export type Token = {
+	type: string;
+	value: string;
+	line: number;
+	col: number;
+	start: number;
+	end: number;
+};
+
+export type AstNode = {
+	type: string;
+	[key: string]: any;
+};
+
+export type AstProgram = {
+	type: string;
+	body: AstNode[];
+	fileName: string;
+};
+
+export type ModuleInclude = {
+	name: string;
+	outRel: string;
+	header?: string;
+	impl?: string | null;
+	exports?: { consts?: string[]; structs?: string[]; hasProtos?: boolean };
+};
+
+export type PreprocessOptions = CompileOptions & {
+	pragmaResolved?: boolean;
+	seen?: Set<string>;
+	moduleIncludes?: ModuleInclude[];
+	siblingHeader?: string | null;
+	source?: string;
+};

package/src/cli.ts

@@ -0,0 +1,214 @@
+import { Command } from "commander";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pkg } from "./package-info.js";
+import { start as startLsp } from "./lsp.js";
+import { toLuauPath } from "./preprocess.js";
+import { installEditorSupport, syncEditorSupport } from "./intellisense.js";
+import { RojoMapper } from "./utils/rojo-mapper.js";
+import { ProcessOrchestrator } from "./utils/process-orchestrator.js";
+import { build as buildProject, init, loadConfig, watch, collectCpp } from "./utils/project.js";
+import { transpileSource } from "./transpile.js";
+import type { BuildOptions, BuildResult } from "./types.js";
+
+const program = new Command();
+
+program
+	.name("cluaupp")
+	.description("Definitive transpiler from C++ subset to structured Luau")
+	.version(pkg.version, "-v, --version", "print version")
+	.showHelpAfterError()
+	.action(() => {
+		program.outputHelp();
+	});
+
+program
+	.command("init")
+	.description("create a game (src/server, src/client, src/shared)")
+	.argument("[folder]", "destination folder", ".")
+	.action(async (folder: string) => {
+		try {
+			await init(path.resolve(process.cwd(), folder));
+		} catch (err) {
+			console.error(err instanceof Error ? err.message : err);
+			process.exit(1);
+		}
+	});
+
+program
+	.command("build")
+	.description("Transpila um arquivo, diretório ou projeto C++ para Luau")
+	.argument("[folder]", "project folder", ".")
+	.option("-i, --input <path>", "Arquivo ou diretório C++ de entrada")
+	.option("-o, --output <path>", "Arquivo ou diretório Luau de saída")
+	.option("-r, --rojo <path>", "Caminho para o default.project.json do Rojo", "./default.project.json")
+	.option("--strict", "Emitir --!strict")
+	.option("--format", "Rodar StyLua no output")
+	.option("--analyze", "Rodar luau-analyze no output")
+	.action(async (folder: string, options: {
+		input?: string;
+		output?: string;
+		rojo: string;
+		strict?: boolean;
+		format?: boolean;
+		analyze?: boolean;
+	}) => {
+		if (options.input) {
+			await buildInput(options);
+			return;
+		}
+		try {
+			buildProject(path.resolve(process.cwd(), folder), {
+				format: options.format === true,
+				analyze: options.analyze === true,
+				rojo: options.rojo,
+			});
+		} catch (err) {
+			console.error(err instanceof Error ? err.message : err);
+			process.exit(1);
+		}
+	});
+
+program
+	.command("watch")
+	.description("rebuild on save")
+	.argument("[folder]", "project folder", ".")
+	.option("-r, --rojo <path>", "Caminho para o default.project.json do Rojo", "./default.project.json")
+	.option("--format", "Rodar StyLua no output")
+	.action((folder: string, options: { rojo?: string; format?: boolean }) => {
+		try {
+			watch(path.resolve(process.cwd(), folder), {
+				format: options.format === true,
+				rojo: options.rojo,
+			});
+		} catch (err) {
+			console.error(err instanceof Error ? err.message : err);
+			process.exit(1);
+		}
+	});
+
+program
+	.command("lsp")
+	.description("Cluaupp subset diagnostics over stdio (JSON-RPC). C++ completion is clangd.")
+	.argument("[folder]", "project folder", ".")
+	.action((folder: string) => {
+		startLsp({ projectRoot: path.resolve(process.cwd(), folder) });
+	});
+
+program
+	.command("intellisense")
+	.alias("intelisense")
+	.description("install LLVM clangd and write compile_commands.json")
+	.argument("[folder]", "project folder", ".")
+	.action(async (folder: string) => {
+		try {
+			const root = path.resolve(process.cwd(), folder);
+			syncEditorSupport(root, loadConfig(root));
+			const installed = await installEditorSupport();
+			console.log("cluaupp: compile_commands.json, .clangd, and .vscode updated in", root);
+			console.log("cluaupp: C++ completion is clangd (include/cluaupp/roblox.hpp)");
+			if (installed.clangd || installed.llvm) {
+				console.log("cluaupp: reload Cursor (Ctrl+Shift+P → Developer: Reload Window)");
+			}
+		} catch (err) {
+			console.error(err instanceof Error ? err.message : err);
+			process.exit(1);
+		}
+	});
+
+async function buildInput(options: {
+	input?: string;
+	output?: string;
+	rojo: string;
+	strict?: boolean;
+	format?: boolean;
+	analyze?: boolean;
+}): Promise<void> {
+	if (!options.input || !options.output) {
+		console.error("[Erro] --input e --output são obrigatórios neste modo.");
+		process.exit(1);
+	}
+
+	const inputPath = path.resolve(options.input);
+	const outputPath = path.resolve(options.output);
+
+	try {
+		await fs.stat(inputPath);
+	} catch {
+		console.error(`[Erro] O caminho de entrada especificado não existe: ${inputPath}`);
+		process.exit(1);
+	}
+
+	console.log("🏁 Inicializando Pipeline do Compilador Cluaupp V2...");
+
+	const mapper = new RojoMapper(path.resolve(options.rojo), path.dirname(inputPath));
+	await mapper.load();
+
+	const inputs = (await fs.stat(inputPath)).isDirectory()
+		? collectCpp(inputPath)
+		: [inputPath];
+
+	if (inputs.length === 0) {
+		console.error("no .cpp/.h/.hpp files in", inputPath);
+		process.exit(1);
+	}
+
+	const outputIsFile = /\.luau$/i.test(outputPath);
+	if (outputIsFile && inputs.length > 1) {
+		console.error("[Erro] --output deve ser um diretório quando a entrada contém vários arquivos.");
+		process.exit(1);
+	}
+
+	for (const file of inputs) {
+		const sourceCode = await fs.readFile(file, "utf8");
+		const rel = path.basename(file);
+		const compiled = transpileSource(sourceCode, rel, {
+			strict: options.strict === true,
+			filePath: file,
+			relativeName: rel,
+			srcDir: path.dirname(file),
+			includeDirs: [path.dirname(file)],
+		}, mapper);
+
+		const dest = outputIsFile ? outputPath : path.join(outputPath, path.basename(toLuauPath(rel)));
+		await fs.mkdir(path.dirname(dest), { recursive: true });
+		const luau = compiled.files[0]?.contents ?? "";
+		await fs.writeFile(dest, luau, "utf8");
+
+		if (options.format === true) {
+			await ProcessOrchestrator.formatWithStyLua(dest);
+		}
+		if (options.analyze === true) {
+			const analysisReport = await ProcessOrchestrator.analyzeWithLuau(dest);
+			if (analysisReport) {
+				console.log("\nRelatório de Análise Estática do Luau:\n", analysisReport);
+			}
+		}
+		console.log(`Transpilação concluída! ${file} → ${dest}`);
+	}
+}
+
+export function build(root: string, options: BuildOptions = {}): BuildResult {
+	return buildProject(root, options);
+}
+
+export { watch, init, program };
+
+export function dispatch(args: string[]): Promise<Command> {
+	return program.parseAsync(["node", "cluaupp", ...args]);
+}
+
+function isMain(): boolean {
+	const entry = process.argv[1];
+	if (!entry) {
+		return false;
+	}
+	return ["cli.js", "cli.ts", "cluaupp.js", "cluau.js"].includes(path.basename(entry));
+}
+
+if (isMain()) {
+	program.parseAsync(process.argv).catch((err: unknown) => {
+		console.error(err instanceof Error ? err.message : err);
+		process.exit(1);
+	});
+}

package/src/compile.ts

@@ -0,0 +1,118 @@
+import path from "node:path";
+import { parse } from "./parse.js";
+import { emit } from "./emit.js";
+import { preprocess, isHeaderFile, toLuauPath, siblingImplementation, siblingHeader, implOutName } from "./preprocess.js";
+import { collectLibraries, insertPreamble } from "./libs.js";
+import { planOutput } from "./architecture.js";
+import { emitHeaderModule, primaryHeaderName } from "./headers.js";
+import type { AstProgram, ModuleInclude, PreprocessOptions } from "./ast.js";
+import type { CompileOptions, CompileServiceResult } from "./types.js";
+
+function shouldAttachRequires(name: string, contents: string): boolean {
+	const file = String(name || "").replace(/\\/g, "/");
+	if (/\.json$/i.test(file) || /\.meta\.json$/i.test(file)) {
+		return false;
+	}
+	const trimmed = String(contents || "").trim();
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+		return false;
+	}
+	return true;
+}
+
+function attachRequires(contents: string, source: string, ast: AstProgram, options: PreprocessOptions, outName: string): string {
+	if (!shouldAttachRequires(outName, contents)) {
+		return contents;
+	}
+	const libraries = String(contents).includes("CluauppLibs") ? [] : collectLibraries(source, ast);
+	return insertPreamble(contents, options.moduleIncludes || [], libraries, outName);
+}
+
+function posixRel(from: string, file: string): string {
+	return path.relative(from, file).replace(/\\/g, "/");
+}
+
+function wireHeaderImpl(ast: AstProgram, fileName: string, options: PreprocessOptions): void {
+	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: ModuleInclude) => spec.name === options.headerImplName)) {
+		options.moduleIncludes.push({
+			name: options.headerImplName,
+			outRel: implOut,
+			exports: { consts: [], structs: [] },
+		});
+	}
+}
+
+function compileHeader(source: string, fileName: string, options: PreprocessOptions, ast: AstProgram): CompileServiceResult {
+	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: [],
+	};
+}
+
+export function compileSource(source: string, fileName?: string, options: CompileOptions = {}): string {
+	const opts = options as PreprocessOptions;
+	opts.moduleIncludes = opts.moduleIncludes || [];
+	const prepared = preprocess(source, opts.filePath || null, opts);
+	const ast = parse(prepared, fileName || "input.cpp");
+	if (isHeaderFile(fileName || "") || isHeaderFile(opts.filePath || "")) {
+		return compileHeader(source, fileName || "header.h", opts, ast).files[0].contents;
+	}
+	const luau = emit(ast, opts);
+	return attachRequires(luau, source, ast, opts, opts.outName || fileName || "input.cpp");
+}
+
+export function compileService(source: string, fileName?: string, options: CompileOptions = {}): CompileServiceResult {
+	const opts = options as PreprocessOptions;
+	opts.moduleIncludes = opts.moduleIncludes || [];
+	const prepared = preprocess(source, opts.filePath || null, opts);
+	const ast = parse(prepared, fileName || "input.cpp");
+	if (isHeaderFile(fileName || "") || isHeaderFile(opts.filePath || "") || isHeaderFile(opts.relativeName || "")) {
+		return compileHeader(source, fileName || "header.h", opts, ast);
+	}
+	const implHeader = opts.filePath ? siblingHeader(opts.filePath) : null;
+	if (implHeader) {
+		opts.skipInit = true;
+	}
+	const planned = planOutput(ast, fileName || "input.cpp", {
+		...opts,
+		relativeName: opts.relativeName || fileName,
+		source: prepared,
+		siblingHeader: implHeader,
+	});
+	if (planned.files) {
+		return {
+			...planned,
+			files: planned.files.map((file: { name: string; contents: string }) => ({
+				...file,
+				contents: attachRequires(file.contents, source, ast, opts, file.name),
+			})),
+		};
+	}
+	const luau = attachRequires(emit(ast, opts), source, ast, opts, planned.outName || opts.outName || fileName || "input.cpp");
+	const name =
+		planned.outName ||
+		opts.outName ||
+		String(fileName || "input.cpp").replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
+	return {
+		kind: planned.kind || "flat",
+		plan: planned.plan,
+		files: [{ name, contents: luau }],
+		stale: planned.stale || [],
+	};
+}