cluaupp 0.1.4 → 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.4",
+	"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,18 +1,23 @@
-"use strict";
-
-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 {
+// @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,
-} = require("./understand");
+	modernScriptOutName,
+} from "./understand.js";
+import { implOutName } from "./preprocess.js";
 
 function header(plan) {
-	const lines = ["--!strict", "-- Compiled by Cluaupp — C++ × Luau"];
+	const lines = [];
+	if (plan && plan.strict) {
+		lines.push("--!strict");
+	}
+	lines.push("-- Compiled by Cluaupp — C++ × Luau");
 	if (plan && plan.reasoning) {
 		for (const line of plan.reasoning) {
 			lines.push(`-- ${line}`);
@@ -328,9 +333,7 @@ function emitDomainController(plan, ast, options) {
 		return decl.type === "decl" || decl.type === "proto" || decl.type === "function" || decl.type === "expr";
 	});
 	const groups = organizeDecls(keep);
-	const subset = { type: "program", body: keep };
 	const name = plan.roles.domain;
-	const libs = collectLibraries(options.source || "", subset);
 	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);
@@ -356,7 +359,7 @@ function emitDomainController(plan, ast, options) {
 	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);
+	return body;
 }
 
 function emitModule(plan, ast, options) {
@@ -366,7 +369,6 @@ function emitModule(plan, ast, options) {
 function emitScriptMeta(runContext) {
 	return `${JSON.stringify(
 		{
-			className: "Script",
 			properties: {
 				RunContext: `Enum.RunContext.${runContext}`,
 			},
@@ -380,7 +382,7 @@ function serviceBootName(plan) {
 	if (plan.isClient) {
 		return "init.client.luau";
 	}
-	return "init.luau";
+	return "init.server.luau";
 }
 
 function serviceFiles(plan, ast, options, dir) {
@@ -404,33 +406,75 @@ function serviceFiles(plan, ast, options, dir) {
 	return files;
 }
 
+function serviceFolderStale(plan, rel) {
+	const dir = path.posix.dirname(rel).replace(/^\.$/, "");
+	const serviceDir = dir && dir !== "." ? dir : plan.isClient ? "client" : "server";
+	const folder = `${serviceDir}/${plan.serviceName}`;
+	return [
+		folder,
+		`${folder}/init.luau`,
+		`${folder}/init.server.luau`,
+		`${folder}/init.client.luau`,
+		`${folder}/init.meta.json`,
+		`${folder}/Main.luau`,
+		`${folder}/PlayersManager.luau`,
+		`${folder}/CacheController.luau`,
+		`${folder}/${plan.typesName}.luau`,
+		plan.roles && plan.roles.domain ? `${folder}/${plan.roles.domain}.luau` : null,
+	].filter(Boolean);
+}
+
 function planOutput(ast, fileName, options = {}) {
 	const plan = analyze(ast, fileName);
+	plan.strict = options.strict === true;
 	const rel = (options.relativeName || fileName).replace(/\\/g, "/");
 	const dir = path.dirname(rel).replace(/^\.$/, "");
 	const outDir = dir && dir !== "." ? dir : "";
 	const prefix = outDir ? `${outDir}/` : "";
+	const stale = serviceFolderStale(plan, rel);
 
-	if (options.architecture === false) {
-		return { kind: "flat", plan, files: null };
+	if (options.siblingHeader) {
+		return {
+			kind: "module",
+			plan,
+			files: [{ name: implOutName(rel), contents: emitModule(plan, ast, { ...options, skipInit: true }) }],
+			stale: [],
+		};
 	}
 
-	if (plan.kind === "legacy") {
-		return { kind: "legacy", plan, files: null, stale: [], outName: legacyOutName(rel) };
+	if (options.architecture === true) {
+		if (plan.kind === "legacy") {
+			return { kind: "legacy", plan, files: null, stale: [], outName: legacyOutName(rel) };
+		}
+
+		if (plan.kind === "service") {
+			const serviceDir = outDir || (plan.isClient ? "client" : "server");
+			const folder = `${serviceDir}/${plan.serviceName}`;
+			const serviceStale = plan.isClient
+				? [`${folder}/init.luau`, `${folder}/init.server.luau`, `${folder}/init.meta.json`]
+				: [`${folder}/init.luau`, `${folder}/init.client.luau`];
+			return {
+				kind: "service",
+				plan,
+				files: serviceFiles(plan, ast, options, serviceDir),
+				stale: serviceStale,
+			};
+		}
+
+		if (plan.kind === "config" || plan.kind === "module") {
+			return {
+				kind: plan.kind,
+				plan,
+				files: [{ name: `${prefix}${plan.serviceName}.luau`, contents: emitModule(plan, ast, options) }],
+				stale: [rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau")],
+			};
+		}
+
+		return { kind: "flat", plan, files: null, stale: [], outName: modernScriptOutName(rel) };
 	}
 
-	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,
-		};
+	if (plan.kind === "legacy") {
+		return { kind: "legacy", plan, files: null, stale, outName: legacyOutName(rel) };
 	}
 
 	if (plan.kind === "config" || plan.kind === "module") {
@@ -438,14 +482,17 @@ function planOutput(ast, fileName, options = {}) {
 			kind: plan.kind,
 			plan,
 			files: [{ name: `${prefix}${plan.serviceName}.luau`, contents: emitModule(plan, ast, options) }],
-			stale: [rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau")],
+			stale: [rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau"), ...stale],
 		};
 	}
 
-	return { kind: "flat", plan, files: null, stale: [] };
+	const outName = modernScriptOutName(rel);
+	const stripped = rel.replace(/\.(server|client|plugin)\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
+	const extraStale = stripped !== outName ? [stripped] : [];
+	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);
+	});
+}