cluaupp 0.1.4 → 0.2.0

package/generated/cli.js

@@ -0,0 +1,191 @@
+"use strict";
+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.build = build;
+exports.dispatch = dispatch;
+const commander_1 = require("commander");
+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 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");
+const project_js_1 = require("./utils/project.js");
+Object.defineProperty(exports, "init", { enumerable: true, get: function () { return project_js_1.init; } });
+Object.defineProperty(exports, "watch", { enumerable: true, get: function () { return project_js_1.watch; } });
+const transpile_js_1 = require("./transpile.js");
+const program = new commander_1.Command();
+exports.program = program;
+program
+    .name("cluaupp")
+    .description("Definitive transpiler from C++ subset to structured Luau")
+    .version(package_info_js_1.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) => {
+    try {
+        await (0, project_js_1.init)(node_path_1.default.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, options) => {
+    if (options.input) {
+        await buildInput(options);
+        return;
+    }
+    try {
+        (0, project_js_1.build)(node_path_1.default.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, options) => {
+    try {
+        (0, project_js_1.watch)(node_path_1.default.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) => {
+    (0, lsp_js_1.start)({ projectRoot: node_path_1.default.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) => {
+    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)");
+        }
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+async function buildInput(options) {
+    if (!options.input || !options.output) {
+        console.error("[Erro] --input e --output são obrigatórios neste modo.");
+        process.exit(1);
+    }
+    const inputPath = node_path_1.default.resolve(options.input);
+    const outputPath = node_path_1.default.resolve(options.output);
+    try {
+        await promises_1.default.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 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)
+        : [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 promises_1.default.readFile(file, "utf8");
+        const rel = node_path_1.default.basename(file);
+        const compiled = (0, transpile_js_1.transpileSource)(sourceCode, rel, {
+            strict: options.strict === true,
+            filePath: file,
+            relativeName: rel,
+            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)));
+        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");
+        if (options.format === true) {
+            await process_orchestrator_js_1.ProcessOrchestrator.formatWithStyLua(dest);
+        }
+        if (options.analyze === true) {
+            const analysisReport = await process_orchestrator_js_1.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}`);
+    }
+}
+function build(root, options = {}) {
+    return (0, project_js_1.build)(root, options);
+}
+function dispatch(args) {
+    return program.parseAsync(["node", "cluaupp", ...args]);
+}
+function isMain() {
+    const entry = process.argv[1];
+    if (!entry) {
+        return false;
+    }
+    return ["cli.js", "cli.ts", "cluaupp.js", "cluau.js"].includes(node_path_1.default.basename(entry));
+}
+if (isMain()) {
+    program.parseAsync(process.argv).catch((err) => {
+        console.error(err instanceof Error ? err.message : err);
+        process.exit(1);
+    });
+}

package/generated/compile.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileSource = compileSource;
+exports.compileService = compileService;
+const node_path_1 = __importDefault(require("node:path"));
+const parse_js_1 = require("./parse.js");
+const emit_js_1 = require("./emit.js");
+const preprocess_js_1 = require("./preprocess.js");
+const libs_js_1 = require("./libs.js");
+const architecture_js_1 = require("./architecture.js");
+const headers_js_1 = require("./headers.js");
+function shouldAttachRequires(name, contents) {
+    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, source, ast, options, outName) {
+    if (!shouldAttachRequires(outName, contents)) {
+        return contents;
+    }
+    const libraries = String(contents).includes("CluauppLibs") ? [] : (0, libs_js_1.collectLibraries)(source, ast);
+    return (0, libs_js_1.insertPreamble)(contents, options.moduleIncludes || [], libraries, outName);
+}
+function posixRel(from, file) {
+    return node_path_1.default.relative(from, file).replace(/\\/g, "/");
+}
+function wireHeaderImpl(ast, fileName, options) {
+    const headerPath = options.filePath || null;
+    const impl = headerPath ? (0, preprocess_js_1.siblingImplementation)(headerPath) : null;
+    if (!impl) {
+        return;
+    }
+    const typeName = (0, headers_js_1.primaryHeaderName)(ast, options.relativeName || fileName);
+    const implRel = options.srcDir ? posixRel(options.srcDir, impl) : node_path_1.default.basename(impl).replace(/\\/g, "/");
+    const implOut = (0, preprocess_js_1.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, ast) {
+    wireHeaderImpl(ast, fileName, options);
+    const rel = (options.relativeName || fileName || "header.h").replace(/\\/g, "/");
+    const outName = (0, preprocess_js_1.toLuauPath)(rel);
+    const luau = attachRequires((0, headers_js_1.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 opts = options;
+    opts.moduleIncludes = opts.moduleIncludes || [];
+    const prepared = (0, preprocess_js_1.preprocess)(source, opts.filePath || null, opts);
+    const ast = (0, parse_js_1.parse)(prepared, fileName || "input.cpp");
+    if ((0, preprocess_js_1.isHeaderFile)(fileName || "") || (0, preprocess_js_1.isHeaderFile)(opts.filePath || "")) {
+        return compileHeader(source, fileName || "header.h", opts, ast).files[0].contents;
+    }
+    const luau = (0, emit_js_1.emit)(ast, opts);
+    return attachRequires(luau, source, ast, opts, opts.outName || fileName || "input.cpp");
+}
+function compileService(source, fileName, options = {}) {
+    const opts = options;
+    opts.moduleIncludes = opts.moduleIncludes || [];
+    const prepared = (0, preprocess_js_1.preprocess)(source, opts.filePath || null, opts);
+    const ast = (0, parse_js_1.parse)(prepared, fileName || "input.cpp");
+    if ((0, preprocess_js_1.isHeaderFile)(fileName || "") || (0, preprocess_js_1.isHeaderFile)(opts.filePath || "") || (0, preprocess_js_1.isHeaderFile)(opts.relativeName || "")) {
+        return compileHeader(source, fileName || "header.h", opts, ast);
+    }
+    const implHeader = opts.filePath ? (0, preprocess_js_1.siblingHeader)(opts.filePath) : null;
+    if (implHeader) {
+        opts.skipInit = true;
+    }
+    const planned = (0, architecture_js_1.planOutput)(ast, fileName || "input.cpp", {
+        ...opts,
+        relativeName: opts.relativeName || fileName,
+        source: prepared,
+        siblingHeader: implHeader,
+    });
+    if (planned.files) {
+        return {
+            ...planned,
+            files: planned.files.map((file) => ({
+                ...file,
+                contents: attachRequires(file.contents, source, ast, opts, file.name),
+            })),
+        };
+    }
+    const luau = attachRequires((0, emit_js_1.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 || [],
+    };
+}

package/generated/editor-install.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLANGD_ID = void 0;
+exports.editorBin = editorBin;
+exports.isExtensionInstalled = isExtensionInstalled;
+exports.findClangPlusPlus = findClangPlusPlus;
+exports.ensureLlvm = ensureLlvm;
+exports.installMarketplaceExtension = installMarketplaceExtension;
+exports.reportInstall = reportInstall;
+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 node_child_process_1 = require("node:child_process");
+exports.CLANGD_ID = "llvm-vs-code-extensions.vscode-clangd";
+function which(command) {
+    const finder = process.platform === "win32" ? "where" : "which";
+    const result = (0, node_child_process_1.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:")) || null;
+}
+function editorBin() {
+    const found = which("cursor") || which("code");
+    if (found) {
+        return found;
+    }
+    const local = process.env.LOCALAPPDATA || "";
+    const fallbacks = [
+        node_path_1.default.join(local, "Programs", "cursor", "resources", "app", "bin", "cursor.cmd"),
+        node_path_1.default.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) => node_fs_1.default.existsSync(file)) || null;
+}
+function extensionHomes() {
+    return [node_path_1.default.join(node_os_1.default.homedir(), ".cursor", "extensions"), node_path_1.default.join(node_os_1.default.homedir(), ".vscode", "extensions")];
+}
+function isExtensionInstalled(id) {
+    for (const home of extensionHomes()) {
+        if (!node_fs_1.default.existsSync(home)) {
+            continue;
+        }
+        try {
+            if (node_fs_1.default.readdirSync(home).some((name) => name.startsWith(`${id}-`))) {
+                return true;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    const bin = editorBin();
+    if (!bin) {
+        return false;
+    }
+    const listed = (0, node_child_process_1.spawnSync)(bin, ["--list-extensions"], { encoding: "utf8", windowsHide: true, timeout: 20000 });
+    return String(listed.stdout || "").split(/\r?\n/).includes(id);
+}
+function llvmCandidates() {
+    if (process.platform === "win32") {
+        return [
+            "C:/Program Files/LLVM/bin/clang++.exe",
+            "C:/Program Files (x86)/LLVM/bin/clang++.exe",
+            node_path_1.default.join(process.env.ProgramFiles || "C:/Program Files", "LLVM", "bin", "clang++.exe"),
+            "C:/msys64/ucrt64/bin/clang++.exe",
+            "C:/msys64/mingw64/bin/clang++.exe",
+        ];
+    }
+    return ["/usr/bin/clang++", "/usr/local/bin/clang++", "/opt/homebrew/bin/clang++"];
+}
+function findClangPlusPlus() {
+    for (const candidate of llvmCandidates()) {
+        if (candidate && node_fs_1.default.existsSync(candidate)) {
+            return candidate.replace(/\\/g, "/");
+        }
+    }
+    return which("clang++");
+}
+function ensureLlvm() {
+    const found = findClangPlusPlus();
+    if (found) {
+        return { status: "already", path: found };
+    }
+    if (process.platform === "win32" && which("winget")) {
+        console.log("cluaupp: installing LLVM.LLVM (clang++ / clangd) via winget");
+        const result = (0, node_child_process_1.spawnSync)("winget", ["install", "--id", "LLVM.LLVM", "-e", "--accept-package-agreements", "--accept-source-agreements"], { encoding: "utf8", windowsHide: true, timeout: 300000 });
+        const after = findClangPlusPlus();
+        if (after) {
+            return { status: "installed", path: after, how: "winget" };
+        }
+        return {
+            status: "missing",
+            detail: String(result.stderr || result.stdout || "").trim() || "winget did not install LLVM",
+            hint: "winget install --id LLVM.LLVM -e",
+        };
+    }
+    const hint = process.platform === "darwin"
+        ? "brew install llvm"
+        : process.platform === "win32"
+            ? "winget install --id LLVM.LLVM -e"
+            : "sudo apt install clang";
+    return { status: "missing", hint };
+}
+function spawnInstall(bin, target) {
+    const result = (0, node_child_process_1.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 installMarketplaceExtension(id, label) {
+    if (isExtensionInstalled(id)) {
+        return { status: "already", id };
+    }
+    const bin = editorBin();
+    if (!bin) {
+        return { status: "missing-editor", id };
+    }
+    console.log("cluaupp: installing", label || id);
+    const marketplace = spawnInstall(bin, id);
+    if (marketplace.ok) {
+        return { status: "installed", id, how: "marketplace" };
+    }
+    return { status: "failed", id, detail: marketplace.stderr || marketplace.stdout };
+}
+function reportInstall(result, label, extraMissing) {
+    if (!result) {
+        return;
+    }
+    const name = label || result.id;
+    if (result.status === "already") {
+        console.log("cluaupp:", name, "already installed");
+        return;
+    }
+    if (result.status === "installed") {
+        console.log("cluaupp: installed", name, result.how ? `(${result.how})` : "");
+        return;
+    }
+    if (result.status === "missing-editor") {
+        console.error("cluaupp: Cursor/VS Code CLI not found. Install", name, "from the marketplace.");
+        return;
+    }
+    if (result.status === "missing") {
+        console.error("cluaupp: LLVM clang++ not found.", result.hint || extraMissing || "");
+        if (result.detail) {
+            console.error(" ", result.detail.split(/\r?\n/)[0]);
+        }
+        return;
+    }
+    console.error("cluaupp: could not install", name + ":", result.detail || "unknown error");
+    if (extraMissing) {
+        console.error(" ", extraMissing);
+    }
+}