cluaupp 0.1.5 → 0.2.0

package/src/editor-install.ts

@@ -0,0 +1,182 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+export const CLANGD_ID = "llvm-vs-code-extensions.vscode-clangd";
+
+export type InstallResult = {
+	status: string;
+	id?: string;
+	path?: string;
+	how?: string;
+	detail?: string;
+	hint?: string;
+};
+
+function which(command: string): string | null {
+	const finder = process.platform === "win32" ? "where" : "which";
+	const result = 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;
+}
+
+export function editorBin(): string | null {
+	const found = which("cursor") || which("code");
+	if (found) {
+		return found;
+	}
+	const local = process.env.LOCALAPPDATA || "";
+	const fallbacks = [
+		path.join(local, "Programs", "cursor", "resources", "app", "bin", "cursor.cmd"),
+		path.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) => fs.existsSync(file)) || null;
+}
+
+function extensionHomes(): string[] {
+	return [path.join(os.homedir(), ".cursor", "extensions"), path.join(os.homedir(), ".vscode", "extensions")];
+}
+
+export function isExtensionInstalled(id: string): boolean {
+	for (const home of extensionHomes()) {
+		if (!fs.existsSync(home)) {
+			continue;
+		}
+		try {
+			if (fs.readdirSync(home).some((name) => name.startsWith(`${id}-`))) {
+				return true;
+			}
+		} catch {
+			// ignore
+		}
+	}
+	const bin = editorBin();
+	if (!bin) {
+		return false;
+	}
+	const listed = spawnSync(bin, ["--list-extensions"], { encoding: "utf8", windowsHide: true, timeout: 20000 });
+	return String(listed.stdout || "").split(/\r?\n/).includes(id);
+}
+
+function llvmCandidates(): string[] {
+	if (process.platform === "win32") {
+		return [
+			"C:/Program Files/LLVM/bin/clang++.exe",
+			"C:/Program Files (x86)/LLVM/bin/clang++.exe",
+			path.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++"];
+}
+
+export function findClangPlusPlus(): string | null {
+	for (const candidate of llvmCandidates()) {
+		if (candidate && fs.existsSync(candidate)) {
+			return candidate.replace(/\\/g, "/");
+		}
+	}
+	return which("clang++");
+}
+
+export function ensureLlvm(): InstallResult {
+	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 = 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: string, target: string) {
+	const result = 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,
+	};
+}
+
+export async function installMarketplaceExtension(id: string, label?: string): Promise<InstallResult> {
+	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 };
+}
+
+export function reportInstall(result: InstallResult | null | undefined, label?: string, extraMissing?: string): void {
+	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);
+	}
+}

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

@@ -1,7 +1,6 @@
-"use strict";
-
-const { isInstanceType, isMethod, isDatatype, luauType } = require("./api");
-const { isLibraryType, isLibraryMethod, MODULE_COLON } = require("./libs");
+// @ts-nocheck
+import { isInstanceType, isMethod, isDatatype, luauType } from "./api.js";
+import { isLibraryType, isLibraryMethod, MODULE_COLON } from "./libs.js";
 
 function emit(ast, options = {}) {
 	const strict = options.strict === true;
@@ -529,4 +528,4 @@ function emit(ast, options = {}) {
 	return lines.join("\n");
 }
 
-module.exports = { emit };
+export { emit };

package/src/emitter/luau-codegen.ts

@@ -0,0 +1,187 @@
+import type { TranspilerState } from "../types.js";
+
+const GET_SERVICE = /^const\s+([A-Za-z_][\w]*)\s*=\s*game:GetService\("([A-Za-z_][\w]*)"\)\s*$/;
+const REQUIRE_LINE = /^const\s+([A-Za-z_][\w]*)\s*=\s*require\((.+)\)\s*$/;
+
+export class LuauCodeEmitter {
+	public static emptyState(strict = false): TranspilerState {
+		return {
+			robloxServices: new Set<string>(),
+			moduleRequires: new Map<string, string>(),
+			customTypes: [],
+			constants: [],
+			functions: [],
+			headerLines: [],
+			strict,
+		};
+	}
+
+	public static emit(state: TranspilerState): string {
+		const output: string[] = [];
+		if (state.strict) {
+			output.push("--!strict");
+		}
+		if (state.headerLines.length > 0) {
+			output.push(...state.headerLines);
+		} else {
+			output.push("-- Compiled by Cluaupp — C++ × Luau");
+		}
+		output.push("");
+
+		if (state.robloxServices.size > 0) {
+			for (const service of Array.from(state.robloxServices).sort()) {
+				output.push(`const ${service} = game:GetService("${service}")`);
+			}
+			output.push("");
+		}
+
+		if (state.moduleRequires.size > 0) {
+			for (const [alias, requirePath] of Array.from(state.moduleRequires.entries()).sort(([a], [b]) => a.localeCompare(b))) {
+				output.push(`const ${alias} = require(${requirePath})`);
+			}
+			output.push("");
+		}
+
+		if (state.customTypes.length > 0) {
+			output.push(...state.customTypes);
+			output.push("");
+		}
+
+		if (state.constants.length > 0) {
+			output.push(...state.constants);
+			output.push("");
+		}
+
+		if (state.functions.length > 0) {
+			output.push(...state.functions);
+		} else {
+			output.push("-- Nenhum método ou lógica detectado para transcompilação.");
+		}
+
+		return output.join("\n").replace(/\n{3,}/g, "\n\n") + "\n";
+	}
+
+	public static merge(state: TranspilerState, compiledLuau: string): string {
+		const trimmed = String(compiledLuau || "").trim();
+		if (!trimmed || trimmed.startsWith("{") || trimmed.startsWith("[")) {
+			return compiledLuau;
+		}
+
+		const harvested = harvestPreamble(compiledLuau);
+		for (const service of harvested.services) {
+			state.robloxServices.add(service);
+		}
+		for (const [alias, requirePath] of harvested.requires) {
+			if (!state.moduleRequires.has(alias)) {
+				state.moduleRequires.set(alias, requirePath);
+			}
+		}
+
+		const output: string[] = [];
+		output.push(...(harvested.header.length > 0 ? harvested.header : ["-- Compiled by Cluaupp — C++ × Luau"]));
+		for (const line of state.headerLines) {
+			if (line && !output.includes(line)) {
+				output.push(line);
+			}
+		}
+		if (state.strict && !output.some((line) => line.startsWith("--!strict"))) {
+			output.unshift("--!strict");
+		}
+		output.push("");
+
+		if (state.robloxServices.size > 0) {
+			for (const service of Array.from(state.robloxServices).sort()) {
+				output.push(`const ${service} = game:GetService("${service}")`);
+			}
+			output.push("");
+		}
+
+		if (state.moduleRequires.size > 0) {
+			for (const [alias, requirePath] of Array.from(state.moduleRequires.entries()).sort(([a], [b]) => a.localeCompare(b))) {
+				output.push(`const ${alias} = require(${requirePath})`);
+			}
+			output.push("");
+		}
+
+		const rest = harvested.body.trim();
+		const extraTypes = state.customTypes.filter((line) => !bodyHasDecl(rest, line, /^type\s+(\w+)/));
+		const extraConsts = state.constants.filter((line) => !bodyHasDecl(rest, line, /^const\s+(\w+)/));
+		if (extraTypes.length > 0) {
+			output.push(...extraTypes, "");
+		}
+		if (extraConsts.length > 0) {
+			output.push(...extraConsts, "");
+		}
+		if (rest) {
+			output.push(rest);
+		} else if (state.customTypes.length || state.constants.length || state.functions.length) {
+			if (state.customTypes.length) {
+				output.push(...state.customTypes, "");
+			}
+			if (state.constants.length) {
+				output.push(...state.constants, "");
+			}
+			if (state.functions.length) {
+				output.push(...state.functions);
+			}
+		}
+
+		return `${output.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd()}\n`;
+	}
+}
+
+function harvestPreamble(luau: string): {
+	header: string[];
+	services: Set<string>;
+	requires: Map<string, string>;
+	body: string;
+} {
+	const lines = luau.split(/\r?\n/);
+	const header: string[] = [];
+	const services = new Set<string>();
+	const requires = new Map<string, string>();
+	let i = 0;
+
+	while (i < lines.length && (lines[i].startsWith("--") || lines[i].trim() === "")) {
+		if (lines[i].startsWith("--")) {
+			header.push(lines[i]);
+		}
+		i += 1;
+	}
+
+	while (i < lines.length) {
+		const line = lines[i];
+		if (line.trim() === "") {
+			i += 1;
+			continue;
+		}
+		const service = line.match(GET_SERVICE);
+		if (service && service[1] === service[2]) {
+			services.add(service[1]);
+			i += 1;
+			continue;
+		}
+		const required = line.match(REQUIRE_LINE);
+		if (required) {
+			requires.set(required[1], required[2]);
+			i += 1;
+			continue;
+		}
+		break;
+	}
+
+	return {
+		header,
+		services,
+		requires,
+		body: lines.slice(i).join("\n"),
+	};
+}
+
+function bodyHasDecl(body: string, line: string, pattern: RegExp): boolean {
+	const match = line.match(pattern);
+	if (!match) {
+		return body.includes(line);
+	}
+	return new RegExp(`^(?:export\\s+)?(?:type|const)\\s+${match[1]}\\b`, "m").test(body);
+}

package/src/emitter/translators.ts

@@ -0,0 +1,168 @@
+import type Parser from "tree-sitter";
+import { compileSource } from "../compile.js";
+
+type SyntaxNode = Parser.SyntaxNode;
+
+const TYPE_MAP: Record<string, string> = {
+	"std::string": "string",
+	"std::string_view": "string",
+	string: "string",
+	string_view: "string",
+	bool: "boolean",
+	int: "number",
+	int8_t: "number",
+	int16_t: "number",
+	int32_t: "number",
+	int64_t: "number",
+	uint8_t: "number",
+	uint16_t: "number",
+	uint32_t: "number",
+	uint64_t: "number",
+	float: "number",
+	double: "number",
+	size_t: "number",
+	void: "()",
+	auto: "any",
+};
+
+export function translateCppType(cppType: string): string {
+	const trimmed = cppType
+		.replace(/\b(?:const|constexpr|volatile|static|inline|restrict)\b/g, "")
+		.replace(/\s+/g, " ")
+		.replace(/&/g, "")
+		.replace(/\*/g, "")
+		.trim();
+	if (!trimmed) {
+		return "any";
+	}
+	if (TYPE_MAP[trimmed]) {
+		return TYPE_MAP[trimmed];
+	}
+	const generic = trimmed.match(/^(?:std::)?(?:vector|array|span|LuaArray)\s*<\s*([^>]+)\s*>$/);
+	if (generic) {
+		return `{${translateCppType(generic[1])}}`;
+	}
+	const optional = trimmed.match(/^(?:std::)?optional\s*<\s*([^>]+)\s*>$/);
+	if (optional) {
+		return `${translateCppType(optional[1])}?`;
+	}
+	return trimmed.replace(/^::/, "");
+}
+
+export function translateGetService(node: SyntaxNode): string | null {
+	const functionNode = node.childForFieldName("function") || node.namedChildren[0];
+	if (!functionNode) {
+		return null;
+	}
+	const text = functionNode.text.replace(/\s+/g, "");
+	const generic = text.match(/GetService<(\w+)>/);
+	if (generic) {
+		return generic[1];
+	}
+	if (!text.includes("GetService")) {
+		return null;
+	}
+	const args = functionNode.namedChildren.find((child) => child.type === "template_argument_list");
+	if (args) {
+		const ident = args.namedChildren.find((child) => child.type === "type_identifier" || child.type === "identifier");
+		if (ident) {
+			return ident.text;
+		}
+	}
+	const callText = node.text.replace(/\s+/g, "");
+	const match = callText.match(/GetService<(\w+)>/);
+	return match ? match[1] : null;
+}
+
+export function translateConstant(node: SyntaxNode): string | null {
+	const declarator = node.childForFieldName("declarator");
+	if (!declarator) {
+		return null;
+	}
+	const name = identifierOf(declarator);
+	const valueNode =
+		node.childForFieldName("value") ||
+		declarator.childForFieldName("value") ||
+		namedOf(declarator, "initializer") ||
+		node.namedChildren[node.namedChildren.length - 1];
+	if (!name || !valueNode || valueNode === declarator) {
+		return null;
+	}
+	let value = valueNode.text.replace(/;$/, "").trim();
+	if (value.startsWith("=")) {
+		value = value.slice(1).trim();
+	}
+	if (!value) {
+		return null;
+	}
+	return `const ${name} = ${value}`;
+}
+
+export function translateAlias(node: SyntaxNode, mapType: (cppType: string) => string): string | null {
+	const nameNode = node.childForFieldName("name") || namedOf(node, "type_identifier") || node.namedChildren[1];
+	const typeNode = node.childForFieldName("type") || namedOf(node, "type_descriptor") || node.namedChildren[0];
+	if (!nameNode || !typeNode) {
+		return null;
+	}
+	return `type ${nameNode.text} = ${mapType(typeNode.text)}`;
+}
+
+export function translateStruct(node: SyntaxNode, mapType: (cppType: string) => string): string | null {
+	const nameNode = node.childForFieldName("name") || namedOf(node, "type_identifier");
+	const body = node.childForFieldName("body") || namedOf(node, "field_declaration_list");
+	if (!nameNode) {
+		return null;
+	}
+	if (!body) {
+		return `type ${nameNode.text} = {}`;
+	}
+	const fields: string[] = [];
+	for (const field of body.namedChildren) {
+		if (field.type !== "field_declaration") {
+			continue;
+		}
+		const fieldType = field.childForFieldName("type");
+		const fieldDecl = field.childForFieldName("declarator");
+		const fieldName = fieldDecl ? identifierOf(fieldDecl) : namedOf(field, "field_identifier")?.text;
+		if (!fieldName) {
+			continue;
+		}
+		fields.push(`\t${fieldName}: ${mapType(fieldType?.text || "any")},`);
+	}
+	if (fields.length === 0) {
+		return `type ${nameNode.text} = {}`;
+	}
+	return `type ${nameNode.text} = {\n${fields.join("\n")}\n}`;
+}
+
+export function translateFunction(node: SyntaxNode, fileName: string): string | null {
+	try {
+		const luau = compileSource(node.text, fileName, { skipHeader: true });
+		const trimmed = String(luau || "").trim();
+		return trimmed || null;
+	} catch {
+		const name = identifierOf(node.childForFieldName("declarator") || node) || "fn";
+		return `-- function ${name} (não traduzida)`;
+	}
+}
+
+function identifierOf(node: SyntaxNode): string | null {
+	if (node.type === "identifier" || node.type === "field_identifier" || node.type === "type_identifier") {
+		return node.text;
+	}
+	const direct = node.childForFieldName("declarator") || namedOf(node, "identifier") || namedOf(node, "field_identifier");
+	if (direct) {
+		return identifierOf(direct);
+	}
+	for (const child of node.namedChildren) {
+		const found = identifierOf(child);
+		if (found) {
+			return found;
+		}
+	}
+	return null;
+}
+
+function namedOf(node: SyntaxNode, type: string): SyntaxNode | null {
+	return node.namedChildren.find((child) => child.type === type) || null;
+}

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

@@ -1,7 +1,6 @@
-"use strict";
-
-const path = require("path");
-const { luauType } = require("./api");
+// @ts-nocheck
+import path from "node:path";
+import { luauType } from "./api.js";
 
 function fileStem(fileName) {
 	return path.basename(String(fileName || "module")).replace(/\.(h|hpp|hh|cpp|cc|cxx|c)$/i, "");
@@ -227,7 +226,7 @@ function emitHeaderModule(ast, options = {}) {
 	return lines.join("\n");
 }
 
-module.exports = {
+export {
 	emitHeaderModule,
 	primaryHeaderName,
 	collectHeaderShape,