cluaupp 0.2.2 → 1.0.0

package/generated/api.js

@@ -43,9 +43,23 @@ function luauType(name) {
     if (!name) {
         return null;
     }
-    const cleaned = String(name).replace(/\*+$/, "").replace(/^const\s+/, "").replace(/^Enum::/, "Enum.");
+    const cleaned = String(name)
+        .replace(/\*+$/, "")
+        .replace(/^const\s+/, "")
+        .replace(/^Enum::/, "Enum.")
+        .replace(/\s+/g, " ")
+        .trim();
     if (cleaned in LUAU_TYPES) {
         return LUAU_TYPES[cleaned];
     }
+    const generic = cleaned.match(/^(?:std::)?(?:vector|array|span|LuaArray)\s*<\s*([^>]+)\s*>$/);
+    if (generic) {
+        const inner = luauType(generic[1]) || generic[1];
+        return `{${inner}}`;
+    }
+    const optional = cleaned.match(/^(?:std::)?optional\s*<\s*([^>]+)\s*>$/);
+    if (optional) {
+        return `${luauType(optional[1]) || optional[1]}?`;
+    }
     return cleaned;
 }

package/generated/cli.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.program = exports.init = exports.watch = void 0;
+exports.hasClpp = exports.program = exports.init = exports.watch = void 0;
 exports.build = build;
 exports.dispatch = dispatch;
 const commander_1 = require("commander");
@@ -11,7 +11,10 @@ const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const package_info_js_1 = require("./package-info.js");
 const lsp_js_1 = require("./lsp.js");
-const preprocess_js_1 = require("./preprocess.js");
+const paths_js_1 = require("./clpp/paths.js");
+const contract_js_1 = require("./clpp/contract.js");
+const runner_js_1 = require("./clpp/runner.js");
+Object.defineProperty(exports, "hasClpp", { enumerable: true, get: function () { return runner_js_1.hasClpp; } });
 const intellisense_js_1 = require("./intellisense.js");
 const rojo_mapper_js_1 = require("./utils/rojo-mapper.js");
 const process_orchestrator_js_1 = require("./utils/process-orchestrator.js");
@@ -23,7 +26,7 @@ const program = new commander_1.Command();
 exports.program = program;
 program
     .name("cluaupp")
-    .description("Definitive transpiler from C++ subset to structured Luau")
+    .description("Cluaupp toolchain — compile CL++ to Luau, Rojo, and CluauppLibs")
     .version(package_info_js_1.pkg.version, "-v, --version", "print version")
     .showHelpAfterError()
     .action(() => {
@@ -44,14 +47,14 @@ program
 });
 program
     .command("build")
-    .description("Transpila um arquivo, diretório ou projeto C++ para Luau")
+    .description("Compile a CL++ file, directory, or project to 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")
+    .option("-i, --input <path>", "CL++ file or directory")
+    .option("-o, --output <path>", "Luau file or directory")
+    .option("-r, --rojo <path>", "Path to Rojo default.project.json", "./default.project.json")
+    .option("--strict", "Emit --!strict")
+    .option("--format", "Run StyLua on output")
+    .option("--analyze", "Run luau-analyze on output")
     .action(async (folder, options) => {
     if (options.input) {
         await buildInput(options);
@@ -73,8 +76,8 @@ 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")
+    .option("-r, --rojo <path>", "Path to Rojo default.project.json", "./default.project.json")
+    .option("--format", "Run StyLua on output")
     .action((folder, options) => {
     try {
         (0, project_js_1.watch)(node_path_1.default.resolve(process.cwd(), folder), {
@@ -89,7 +92,7 @@ program
 });
 program
     .command("lsp")
-    .description("Cluaupp subset diagnostics over stdio (JSON-RPC). C++ completion is clangd.")
+    .description("Language server stdio (JSON-RPC). Use `clpp install` for CL++ IntelliSense.")
     .argument("[folder]", "project folder", ".")
     .action((folder) => {
     (0, lsp_js_1.start)({ projectRoot: node_path_1.default.resolve(process.cwd(), folder) });
@@ -97,18 +100,32 @@ program
 program
     .command("intellisense")
     .alias("intelisense")
-    .description("install LLVM clangd and write compile_commands.json")
+    .description("Point the editor at CL++ (`clpp install`)")
     .argument("[folder]", "project folder", ".")
     .action(async (folder) => {
     try {
         const root = node_path_1.default.resolve(process.cwd(), folder);
         (0, intellisense_js_1.syncEditorSupport)(root, (0, project_js_1.loadConfig)(root));
-        const installed = await (0, intellisense_js_1.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)");
+        await (0, intellisense_js_1.installEditorSupport)();
+        console.log("cluaupp: editor associations written in", root);
+        console.log("cluaupp:", contract_js_1.CLPP_INSTALL_HINT);
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+program
+    .command("language")
+    .description("CL++ manifest (`clpp api manifest`)")
+    .action(() => {
+    try {
+        (0, runner_js_1.resolveClppBinary)();
+        const version = (0, runner_js_1.clppVersion)();
+        if (version) {
+            console.log("clpp", version);
         }
+        console.log(JSON.stringify((0, runner_js_1.clppManifest)(), null, "\t"));
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : err);
@@ -129,14 +146,13 @@ async function buildInput(options) {
         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 rojo_mapper_js_1.RojoMapper(node_path_1.default.resolve(options.rojo), node_path_1.default.dirname(inputPath));
     await mapper.load();
     const inputs = (await promises_1.default.stat(inputPath)).isDirectory()
-        ? (0, project_js_1.collectCpp)(inputPath)
+        ? (0, paths_js_1.collectSources)(inputPath)
         : [inputPath];
     if (inputs.length === 0) {
-        console.error("no .cpp/.h/.hpp files in", inputPath);
+        console.error("no .clpp/.clp/.clh files in", inputPath);
         process.exit(1);
     }
     const outputIsFile = /\.luau$/i.test(outputPath);
@@ -154,7 +170,7 @@ async function buildInput(options) {
             srcDir: node_path_1.default.dirname(file),
             includeDirs: [node_path_1.default.dirname(file)],
         }, mapper);
-        const dest = outputIsFile ? outputPath : node_path_1.default.join(outputPath, node_path_1.default.basename((0, preprocess_js_1.toLuauPath)(rel)));
+        const dest = outputIsFile ? outputPath : node_path_1.default.join(outputPath, node_path_1.default.basename((0, paths_js_1.toLuauPath)(rel)));
         await promises_1.default.mkdir(node_path_1.default.dirname(dest), { recursive: true });
         const luau = compiled.files[0]?.contents ?? "";
         await promises_1.default.writeFile(dest, luau, "utf8");
@@ -167,7 +183,7 @@ async function buildInput(options) {
                 console.log("\nRelatório de Análise Estática do Luau:\n", analysisReport);
             }
         }
-        console.log(`Transpilação concluída! ${file} → ${dest}`);
+        console.log(`Compiled ${file} → ${dest}`);
     }
 }
 function build(root, options = {}) {

package/generated/clpp/contract.js

@@ -0,0 +1,5 @@
+"use strict";
+/** Stable CL++ ↔ Cluaupp contract. Cluaupp invokes the `clpp` binary. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLPP_INSTALL_HINT = void 0;
+exports.CLPP_INSTALL_HINT = "Install CL++ and put `clpp` on PATH: https://github.com/KartzRbx/CLPP (`cargo install --path .` then `clpp install`). Override with CLPP_PATH.";

package/generated/clpp/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toLuauPath = exports.siblingHeader = exports.scriptKind = exports.isTaggedScript = exports.isSourceFile = exports.isImplFile = exports.isHeaderFile = exports.isEngineStub = exports.fileStem = exports.emitKind = exports.collectSources = exports.SOURCE_EXTS = exports.shouldSkipInit = exports.clppLuauToGame = exports.resolveClppBinary = exports.hasClpp = exports.clppVersion = exports.clppManifest = exports.compileViaClpp = exports.CLPP_INSTALL_HINT = void 0;
+var contract_js_1 = require("./contract.js");
+Object.defineProperty(exports, "CLPP_INSTALL_HINT", { enumerable: true, get: function () { return contract_js_1.CLPP_INSTALL_HINT; } });
+var runner_js_1 = require("./runner.js");
+Object.defineProperty(exports, "compileViaClpp", { enumerable: true, get: function () { return runner_js_1.compileViaClpp; } });
+Object.defineProperty(exports, "clppManifest", { enumerable: true, get: function () { return runner_js_1.clppManifest; } });
+Object.defineProperty(exports, "clppVersion", { enumerable: true, get: function () { return runner_js_1.clppVersion; } });
+Object.defineProperty(exports, "hasClpp", { enumerable: true, get: function () { return runner_js_1.hasClpp; } });
+Object.defineProperty(exports, "resolveClppBinary", { enumerable: true, get: function () { return runner_js_1.resolveClppBinary; } });
+var postprocess_js_1 = require("./postprocess.js");
+Object.defineProperty(exports, "clppLuauToGame", { enumerable: true, get: function () { return postprocess_js_1.clppLuauToGame; } });
+Object.defineProperty(exports, "shouldSkipInit", { enumerable: true, get: function () { return postprocess_js_1.shouldSkipInit; } });
+var paths_js_1 = require("./paths.js");
+Object.defineProperty(exports, "SOURCE_EXTS", { enumerable: true, get: function () { return paths_js_1.SOURCE_EXTS; } });
+Object.defineProperty(exports, "collectSources", { enumerable: true, get: function () { return paths_js_1.collectSources; } });
+Object.defineProperty(exports, "emitKind", { enumerable: true, get: function () { return paths_js_1.emitKind; } });
+Object.defineProperty(exports, "fileStem", { enumerable: true, get: function () { return paths_js_1.fileStem; } });
+Object.defineProperty(exports, "isEngineStub", { enumerable: true, get: function () { return paths_js_1.isEngineStub; } });
+Object.defineProperty(exports, "isHeaderFile", { enumerable: true, get: function () { return paths_js_1.isHeaderFile; } });
+Object.defineProperty(exports, "isImplFile", { enumerable: true, get: function () { return paths_js_1.isImplFile; } });
+Object.defineProperty(exports, "isSourceFile", { enumerable: true, get: function () { return paths_js_1.isSourceFile; } });
+Object.defineProperty(exports, "isTaggedScript", { enumerable: true, get: function () { return paths_js_1.isTaggedScript; } });
+Object.defineProperty(exports, "scriptKind", { enumerable: true, get: function () { return paths_js_1.scriptKind; } });
+Object.defineProperty(exports, "siblingHeader", { enumerable: true, get: function () { return paths_js_1.siblingHeader; } });
+Object.defineProperty(exports, "toLuauPath", { enumerable: true, get: function () { return paths_js_1.toLuauPath; } });

package/generated/clpp/paths.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOURCE_EXTS = void 0;
+exports.isSourceFile = isSourceFile;
+exports.isEngineStub = isEngineStub;
+exports.isHeaderFile = isHeaderFile;
+exports.isImplFile = isImplFile;
+exports.toLuauPath = toLuauPath;
+exports.fileStem = fileStem;
+exports.scriptKind = scriptKind;
+exports.emitKind = emitKind;
+exports.isTaggedScript = isTaggedScript;
+exports.siblingHeader = siblingHeader;
+exports.collectSources = collectSources;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.SOURCE_EXTS = [".clpp", ".clp", ".clh"];
+function isSourceFile(fileName) {
+    return exports.SOURCE_EXTS.includes(node_path_1.default.extname(fileName).toLowerCase());
+}
+function isEngineStub(filePath) {
+    const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+    return (normalized.includes("/include/cluaupp/") ||
+        normalized.includes("/include/clpp/") ||
+        normalized.includes("/include/cluau/") ||
+        normalized.includes("/stdlib/") ||
+        normalized.endsWith("/roblox.hpp") ||
+        normalized.endsWith("/roblox.h") ||
+        normalized.endsWith("/roblox.clh"));
+}
+function isHeaderFile(fileName) {
+    return node_path_1.default.extname(fileName).toLowerCase() === ".clh";
+}
+function isImplFile(fileName) {
+    const ext = node_path_1.default.extname(fileName).toLowerCase();
+    return ext === ".clp" || ext === ".clpp";
+}
+function toLuauPath(filePath) {
+    return String(filePath).replace(/\.(clpp|clp|clh)$/i, ".luau");
+}
+function fileStem(fileName) {
+    let name = node_path_1.default.basename(fileName);
+    const lower = name.toLowerCase();
+    for (const ext of [".clpp", ".clp", ".clh"]) {
+        if (lower.endsWith(ext)) {
+            name = name.slice(0, -ext.length);
+            break;
+        }
+    }
+    const tagged = name.toLowerCase();
+    for (const tag of [".legacy.server", ".legacy.client", ".legacy", ".server", ".client", ".plugin"]) {
+        if (tagged.endsWith(tag)) {
+            name = name.slice(0, -tag.length);
+            break;
+        }
+    }
+    return name;
+}
+function scriptKind(fileName) {
+    const name = node_path_1.default.basename(fileName).toLowerCase();
+    if (name.endsWith(".clh")) {
+        return "header";
+    }
+    if (name.includes(".legacy.")) {
+        return "legacy";
+    }
+    if (name.includes(".server.")) {
+        return "server";
+    }
+    if (name.includes(".client.")) {
+        return "client";
+    }
+    if (name.includes(".plugin.")) {
+        return "plugin";
+    }
+    return "module";
+}
+function emitKind(fileName) {
+    const kind = scriptKind(fileName);
+    if (kind === "legacy") {
+        return "legacy";
+    }
+    if (kind === "module" || kind === "header") {
+        return "module";
+    }
+    return "flat";
+}
+function isTaggedScript(fileName) {
+    const kind = scriptKind(fileName);
+    return kind === "server" || kind === "client" || kind === "plugin" || kind === "legacy";
+}
+function siblingHeader(implPath) {
+    if (!implPath || isHeaderFile(implPath)) {
+        return null;
+    }
+    const dir = node_path_1.default.dirname(implPath);
+    const stem = fileStem(implPath);
+    const candidate = node_path_1.default.join(dir, `${stem}.clh`);
+    if (node_fs_1.default.existsSync(candidate)) {
+        return candidate;
+    }
+    return null;
+}
+function collectSources(dir, files = []) {
+    if (!node_fs_1.default.existsSync(dir)) {
+        return files;
+    }
+    for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+        const full = node_path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            collectSources(full, files);
+        }
+        else if (isSourceFile(entry.name)) {
+            files.push(full);
+        }
+    }
+    return files;
+}

package/generated/clpp/postprocess.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldSkipInit = shouldSkipInit;
+exports.clppLuauToGame = clppLuauToGame;
+const libs_js_1 = require("../libs.js");
+const paths_js_1 = require("./paths.js");
+function insertAfterHeader(luau, block) {
+    const match = String(luau).match(/^(?:--[^\n]*\n)+/);
+    if (!match) {
+        return `${block}\n${luau}`;
+    }
+    const insertAt = match[0].length;
+    const rest = luau.slice(insertAt).replace(/^\n*/, "\n");
+    return `${luau.slice(0, insertAt)}\n${block}\n${rest}`;
+}
+function rewriteClppLibs(luau) {
+    return String(luau).replace(/require\(\s*ClppLibs\.([A-Za-z0-9_]+)\s*\)/g, (_all, name) => {
+        return (0, libs_js_1.requireCluauppLib)(name);
+    });
+}
+function ensureReplicatedStorage(luau) {
+    if (!luau.includes("CluauppLibs")) {
+        return luau;
+    }
+    if (/GetService\(\s*"ReplicatedStorage"\s*\)/.test(luau)) {
+        return luau;
+    }
+    return insertAfterHeader(luau, 'const ReplicatedStorage = game:GetService("ReplicatedStorage")');
+}
+function stripInitCall(luau) {
+    return String(luau).replace(/\ninit\(\)\s*\n?$/m, "\n");
+}
+function ensureStrict(luau, strict) {
+    if (!strict || /^\s*--!strict\b/m.test(luau)) {
+        return luau;
+    }
+    if (luau.startsWith("--")) {
+        return `--!strict\n${luau}`;
+    }
+    return `--!strict\n${luau}`;
+}
+function librarySpecs(names) {
+    const specs = [];
+    const seen = new Set();
+    for (const name of names || []) {
+        const spec = libs_js_1.MODULES[name];
+        if (!spec || seen.has(spec.bind)) {
+            continue;
+        }
+        seen.add(spec.bind);
+        specs.push(spec);
+    }
+    return specs;
+}
+function missingLibraries(luau, names) {
+    return librarySpecs(names).filter((spec) => {
+        return !luau.includes(`CluauppLibs.${spec.file}`) && !new RegExp(`\\bconst ${spec.bind}\\b`).test(luau);
+    });
+}
+function shouldSkipInit(fileName, hasSiblingHeader) {
+    if (!hasSiblingHeader) {
+        return false;
+    }
+    return !(0, paths_js_1.isTaggedScript)(fileName);
+}
+function clppLuauToGame(artifact, options) {
+    let luau = rewriteClppLibs(artifact.luau || "");
+    luau = ensureReplicatedStorage(luau);
+    if (options.skipInit) {
+        luau = stripInitCall(luau);
+    }
+    luau = ensureStrict(luau, options.strict);
+    const missing = missingLibraries(luau, artifact.libraries);
+    if (missing.length > 0) {
+        luau = (0, libs_js_1.insertPreamble)(luau, [], missing, options.outName);
+    }
+    return luau;
+}

package/generated/clpp/runner.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasClpp = hasClpp;
+exports.resolveClppBinary = resolveClppBinary;
+exports.compileViaClpp = compileViaClpp;
+exports.clppManifest = clppManifest;
+exports.clppVersion = clppVersion;
+const node_child_process_1 = require("node:child_process");
+const contract_js_1 = require("./contract.js");
+const MISSING_CLPP = `cluaupp: clpp not found. ${contract_js_1.CLPP_INSTALL_HINT}`;
+function whichClpp() {
+    if (process.env.CLPP_PATH) {
+        return process.env.CLPP_PATH;
+    }
+    const finder = process.platform === "win32" ? "where" : "which";
+    const found = (0, node_child_process_1.spawnSync)(finder, ["clpp"], { encoding: "utf8", windowsHide: true });
+    if (found.status !== 0) {
+        return null;
+    }
+    const line = String(found.stdout || "")
+        .split(/\r?\n/)
+        .map((item) => item.trim())
+        .find((item) => item.length > 0);
+    return line || "clpp";
+}
+function hasClpp() {
+    return Boolean(whichClpp());
+}
+function resolveClppBinary() {
+    const bin = whichClpp();
+    if (!bin) {
+        throw new Error(MISSING_CLPP);
+    }
+    return bin;
+}
+function parseArtifact(stdout, fileName, fallbackError) {
+    const text = String(stdout || "").trim();
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed && typeof parsed === "object") {
+            return parsed;
+        }
+    }
+    catch {
+        // fall through
+    }
+    return {
+        ok: false,
+        luau: "",
+        fileName,
+        outputHint: "",
+        scriptKind: null,
+        isScript: false,
+        isHeader: false,
+        rojoClass: "ModuleScript",
+        libraries: [],
+        error: fallbackError || "clpp returned invalid JSON",
+    };
+}
+function compileViaClpp(request) {
+    const bin = resolveClppBinary();
+    const payload = JSON.stringify({
+        source: request.source,
+        fileName: request.fileName,
+        strict: request.strict,
+    });
+    const result = (0, node_child_process_1.spawnSync)(bin, ["api", "compile"], {
+        input: payload,
+        encoding: "utf8",
+        cwd: request.cwd,
+        maxBuffer: 16 * 1024 * 1024,
+        windowsHide: true,
+    });
+    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})`);
+    }
+    return artifact;
+}
+function clppManifest() {
+    const bin = resolveClppBinary();
+    const result = (0, node_child_process_1.spawnSync)(bin, ["api", "manifest"], {
+        encoding: "utf8",
+        windowsHide: true,
+    });
+    if (result.status !== 0) {
+        throw new Error(String(result.stderr || result.error?.message || "clpp api manifest failed"));
+    }
+    return JSON.parse(result.stdout);
+}
+function clppVersion() {
+    const bin = whichClpp();
+    if (!bin) {
+        return null;
+    }
+    const result = (0, node_child_process_1.spawnSync)(bin, ["--version"], { encoding: "utf8", windowsHide: true });
+    if (result.status !== 0) {
+        return null;
+    }
+    return String(result.stdout || "").trim() || null;
+}