cluaupp 0.1.5 → 0.2.0

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

@@ -1,9 +1,14 @@
-"use strict";
-
-const path = require("path");
-const { luauType } = require("./api");
-
-const EXT = "(cpp|cc|cxx|c|h|hpp|hh)";
+// @ts-nocheck
+import path from "node:path";
+import { luauType } from "./api.js";
+import {
+	INTENTS,
+	walk,
+	namesIn,
+	parseFileTag,
+	scoreIntents,
+	determineArchitecture,
+} from "./system-understander.js";
 
 const VALUE_CLASSES = {
 	IntValue: { luau: "number", instance: "IntValue", fallback: "0" },
@@ -12,158 +17,7 @@ const VALUE_CLASSES = {
 	BoolValue: { luau: "boolean", instance: "BoolValue", fallback: "false" },
 };
 
-// roblox-ts ScriptType is a filename key. Flamework then stamps
-// @Service / @Controller identifiers. Cluaupp uses the same first key
-// (.server / .client / .legacy.* / none) then scores AST intents.
-const INTENTS = {
-	players: {
-		role: "manager",
-		module: "PlayersManager",
-		tokens: ["GetPlayers", "PlayerAdded", "PlayerRemoving", "Players"],
-	},
-	cache: {
-		role: "controller",
-		module: "CacheController",
-		tokens: ["Folder", "IntValue", "StringValue", "BoolValue", "NumberValue", "leaderstats"],
-	},
-	combat: {
-		role: "controller",
-		module: "CombatController",
-		tokens: [
-			"TakeDamage",
-			"Humanoid",
-			"Raycast",
-			"RaycastParams",
-			"Hitbox",
-			"Health",
-			"Damage",
-			"Weapon",
-			"Tool",
-			"Activated",
-			"Combat",
-			"Hurt",
-			"Attack",
-		],
-	},
-	input: {
-		role: "controller",
-		module: "InputController",
-		tokens: [
-			"UserInputService",
-			"ContextActionService",
-			"InputBegan",
-			"InputEnded",
-			"InputChanged",
-			"Mouse",
-			"GetMouse",
-			"PreferredInput",
-		],
-	},
-	ui: {
-		role: "controller",
-		module: "ViewController",
-		tokens: [
-			"PlayerGui",
-			"ScreenGui",
-			"BillboardGui",
-			"SurfaceGui",
-			"TextLabel",
-			"TextButton",
-			"Frame",
-			"ImageLabel",
-			"TweenService",
-			"Twinkle",
-		],
-	},
-	net: {
-		role: "controller",
-		module: "NetController",
-		tokens: [
-			"RemoteEvent",
-			"RemoteFunction",
-			"UnreliableRemoteEvent",
-			"FireServer",
-			"FireAllClients",
-			"FireClient",
-			"OnServerEvent",
-			"OnClientEvent",
-			"Net",
-			"NetEvent",
-		],
-	},
-	data: {
-		role: "controller",
-		module: "DataController",
-		tokens: [
-			"DataStore",
-			"DataStoreService",
-			"DataService",
-			"SetAsync",
-			"GetAsync",
-			"UpdateAsync",
-			"ProfileStore",
-			"GetChangedSignal",
-			"WaitFor",
-			"Paths",
-		],
-	},
-	character: {
-		role: "controller",
-		module: "CharacterController",
-		tokens: ["CharacterAdded", "CharacterRemoving", "HumanoidRootPart", "GetPivot", "PivotTo", "Character"],
-	},
-	animation: {
-		role: "controller",
-		module: "AnimationController",
-		tokens: ["Animator", "Animation", "AnimationTrack", "LoadAnimation"],
-	},
-	inventory: {
-		role: "controller",
-		module: "InventoryController",
-		tokens: ["Backpack", "Inventory"],
-	},
-};
-
-function walk(node, visit) {
-	if (!node || typeof node !== "object") {
-		return;
-	}
-	visit(node);
-	for (const value of Object.values(node)) {
-		if (Array.isArray(value)) {
-			for (const item of value) {
-				walk(item, visit);
-			}
-		} else if (value && typeof value === "object") {
-			walk(value, visit);
-		}
-	}
-}
-
-function namesIn(ast, options = {}) {
-	const found = new Set();
-	walk(ast, (node) => {
-		if (node.type === "call" && node.name) {
-			found.add(node.name);
-		}
-		if (node.type === "member" && node.name) {
-			found.add(node.name);
-		}
-		if (node.type === "ident" && node.name) {
-			found.add(node.name);
-		}
-		if (node.type === "new" && node.className) {
-			found.add(node.className);
-		}
-		if (node.type === "getService" && node.service) {
-			found.add(node.service);
-		}
-		if (options.strings !== false && node.type === "string" && node.value) {
-			found.add(node.value);
-		}
-	});
-	return found;
-}
+const EXT = "(cpp|cc|cxx|c|h|hpp|hh)";
 
 function capitalize(word) {
 	if (!word) {
@@ -196,51 +50,6 @@ function toPascalServiceName(fileName) {
 	return capitalize(base);
 }
 
-function parseFileTag(fileName) {
-	const base = path.basename(fileName);
-	if (new RegExp(`\\.legacy\\.plugin\\.${EXT}$`, "i").test(base)) {
-		return { key: "legacy.plugin", emit: "legacy", runtime: "plugin", rojo: "Script", runContext: "Plugin" };
-	}
-	if (new RegExp(`\\.legacy\\.server\\.${EXT}$`, "i").test(base)) {
-		return { key: "legacy.server", emit: "legacy", runtime: "server", rojo: "Script", runContext: null };
-	}
-	if (new RegExp(`\\.legacy\\.client\\.${EXT}$`, "i").test(base)) {
-		return { key: "legacy.client", emit: "legacy", runtime: "client", rojo: "LocalScript", runContext: null };
-	}
-	if (new RegExp(`\\.legacy\\.${EXT}$`, "i").test(base)) {
-		return { key: "legacy", emit: "legacy", runtime: "server", rojo: "Script", runContext: null };
-	}
-	if (new RegExp(`\\.plugin\\.${EXT}$`, "i").test(base)) {
-		return { key: "plugin", emit: "service", runtime: "plugin", rojo: "Script", runContext: "Plugin" };
-	}
-	if (new RegExp(`\\.server\\.${EXT}$`, "i").test(base)) {
-		return { key: "server", emit: "service", runtime: "server", rojo: "Script", runContext: "Server" };
-	}
-	if (new RegExp(`\\.client\\.${EXT}$`, "i").test(base)) {
-		return { key: "client", emit: "service", runtime: "client", rojo: "LocalScript", runContext: "Client" };
-	}
-	return { key: "module", emit: "module", runtime: "shared", rojo: "ModuleScript", runContext: null };
-}
-
-function scoreIntents(named) {
-	const scored = [];
-	for (const [name, spec] of Object.entries(INTENTS)) {
-		const evidence = spec.tokens.filter((token) => named.has(token));
-		if (evidence.length === 0) {
-			continue;
-		}
-		scored.push({
-			name,
-			score: evidence.length,
-			evidence,
-			role: spec.role,
-			module: spec.module,
-		});
-	}
-	scored.sort((a, b) => b.score - a.score);
-	return scored;
-}
-
 function literal(node) {
 	if (!node) {
 		return null;
@@ -414,11 +223,12 @@ function keepReferencedFunctions(ast, classified) {
 }
 
 function analyze(ast, fileName) {
-	const tag = parseFileTag(fileName);
+	const report = determineArchitecture(fileName, ast);
+	const tag = report.fileTag;
 	const named = namesIn(ast);
 	const { stats, folderName } = collectStats(ast);
 	const consts = collectConsts(ast);
-	const intents = scoreIntents(named);
+	const intents = scoreIntents(named, tag.runtime);
 	const functions = classifyFunctions(ast, intents);
 	const trivial = isTrivial(ast);
 	const constsOnly = onlyConsts(ast);
@@ -451,10 +261,7 @@ function analyze(ast, fileName) {
 	}
 
 	const reasoning = [
-		`tag ${tag.key} → ${tag.rojo} (${tag.emit})`,
-		intents.length > 0
-			? `intents ${intents.map((item) => `${item.name}:${item.score}`).join(", ")}`
-			: "intents (none — entry or module)",
+		...report.reasoning,
 		kind === "service"
 			? `roles ${["Main", roles.players ? "PlayersManager" : null, roles.cache ? "CacheController" : null, roles.domain, `${serviceName}Types`].filter(Boolean).join(", ")}`
 			: `kind ${kind}`,
@@ -477,6 +284,7 @@ function analyze(ast, fileName) {
 		consts,
 		functions,
 		fileName,
+		understand: report,
 		reasoning,
 	};
 }
@@ -498,7 +306,7 @@ function legacyOutName(relativeName) {
 		.replace(new RegExp(`\\.${EXT}$`, "i"), ".luau");
 }
 
-module.exports = {
+export {
 	VALUE_CLASSES,
 	INTENTS,
 	walk,
@@ -510,4 +318,5 @@ module.exports = {
 	legacyOutName,
 	modernScriptOutName,
 	looksLikeCacheSetup,
+	determineArchitecture,
 };

package/src/utils/process-orchestrator.ts

@@ -0,0 +1,72 @@
+import { spawn, spawnSync } from "node:child_process";
+import { childEnv } from "./safe-paths.js";
+
+type ToolResult = {
+	status: number | null;
+	stdout: string;
+	stderr: string;
+	error?: string;
+};
+
+function runTool(bin: string, args: string[], timeout = 120000): ToolResult {
+	const result = spawnSync(bin, args, {
+		encoding: "utf8",
+		windowsHide: true,
+		shell: false,
+		env: childEnv(),
+		timeout,
+	});
+	return {
+		status: result.status,
+		stdout: String(result.stdout || ""),
+		stderr: String(result.stderr || ""),
+		error: result.error ? result.error.message : undefined,
+	};
+}
+
+function formatError(result: ToolResult): string {
+	return (result.stderr || result.stdout || result.error || "").trim();
+}
+
+export class ProcessOrchestrator {
+	public static async formatWithStyLua(filePath: string): Promise<void> {
+		await new Promise<void>((resolve) => {
+			const child = spawn("stylua", [filePath], {
+				windowsHide: true,
+				shell: false,
+				env: childEnv(),
+			});
+			child.on("error", (error) => {
+				console.warn(`[Aviso] Falha ao executar StyLua. Certifique-se de que está instalado. Detalhes: ${error.message}`);
+				resolve();
+			});
+			child.on("close", (status) => {
+				if (status !== 0) {
+					console.warn("[Aviso] Falha ao executar StyLua. Certifique-se de que está instalado.");
+				}
+				resolve();
+			});
+		});
+	}
+
+	public static formatWithStyLuaSync(filePath: string): void {
+		const result = runTool("stylua", [filePath]);
+		if (result.status !== 0) {
+			const details = formatError(result);
+			console.warn(`[Aviso] Falha ao executar StyLua. Certifique-se de que está instalado.${details ? ` Detalhes: ${details}` : ""}`);
+		}
+	}
+
+	public static async analyzeWithLuau(filePath: string): Promise<string | null> {
+		return ProcessOrchestrator.analyzeWithLuauSync(filePath);
+	}
+
+	public static analyzeWithLuauSync(filePath: string): string | null {
+		const result = runTool("luau-analyze", [filePath]);
+		const details = formatError(result);
+		if (result.status === 0) {
+			return details || null;
+		}
+		return details || "Falha na análise estrutural ou erros encontrados pelo analisador Luau.";
+	}
+}