cluaupp 1.4.1 → 1.5.1

package/generated/api/resolver.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashBuffer = hashBuffer;
+exports.mapRobloxType = mapRobloxType;
+exports.mapParameter = mapParameter;
+exports.typeToClpp = typeToClpp;
+exports.typeToLuau = typeToLuau;
+exports.eventSignalType = eventSignalType;
+const node_crypto_1 = require("node:crypto");
+const PRIMITIVE_MAP = {
+    bool: "boolean",
+    boolean: "boolean",
+    int: "int",
+    int64: "int64",
+    float: "float",
+    double: "double",
+    number: "double",
+    string: "string",
+    null: "void",
+    void: "void",
+    nil: "void",
+};
+function hashBuffer(data) {
+    return (0, node_crypto_1.createHash)("sha256").update(data).digest("hex");
+}
+function mapRobloxType(ref) {
+    if (!ref) {
+        return { kind: "Unknown" };
+    }
+    if (typeof ref === "string") {
+        return mapNamedType(ref);
+    }
+    const category = String(ref.Category || "");
+    const name = String(ref.Name || "");
+    let mapped;
+    switch (category) {
+        case "Primitive":
+            mapped = mapNamedType(name);
+            break;
+        case "Class":
+            mapped = { kind: "Class", name };
+            break;
+        case "Enum":
+            mapped = { kind: "Enum", name };
+            break;
+        case "DataType":
+            if (name === "Function") {
+                mapped = {
+                    kind: "Function",
+                    parameters: [{ kind: "Any" }],
+                    returns: [{ kind: "Any" }],
+                    variadic: true,
+                };
+            }
+            else if (name === "buffer" || name === "Buffer") {
+                mapped = { kind: "Buffer" };
+            }
+            else {
+                mapped = { kind: "Datatype", name };
+            }
+            break;
+        case "Group":
+            if (name === "Array") {
+                mapped = { kind: "Array", element: { kind: "Any" } };
+            }
+            else if (name === "Dictionary" || name === "Map") {
+                mapped = {
+                    kind: "Dictionary",
+                    key: { kind: "Any" },
+                    value: { kind: "Any" },
+                };
+            }
+            else if (name === "Tuple") {
+                mapped = { kind: "Tuple", elements: [{ kind: "Any" }] };
+            }
+            else if (name === "Variant") {
+                mapped = { kind: "Any" };
+            }
+            else {
+                mapped = {
+                    kind: "Unsupported",
+                    raw: `${category}:${name}`,
+                    reason: `Group type ${name} has no direct CL++ mapping yet`,
+                };
+            }
+            break;
+        default:
+            if (!name) {
+                mapped = { kind: "Unknown" };
+            }
+            else {
+                mapped = mapNamedType(name);
+            }
+    }
+    if (ref.Optional || /\?$/.test(name)) {
+        return { kind: "Optional", inner: stripOptionalMarker(mapped) };
+    }
+    return mapped;
+}
+function stripOptionalMarker(type) {
+    if (type.kind === "Class" || type.kind === "Enum" || type.kind === "Datatype" || type.kind === "Primitive") {
+        return { ...type, name: type.name.replace(/\?$/, "") };
+    }
+    return type;
+}
+function mapNamedType(rawName) {
+    const name = rawName.replace(/\?$/, "");
+    if (!name) {
+        return { kind: "Unknown" };
+    }
+    if (name === "any") {
+        return { kind: "Any" };
+    }
+    if (name === "unknown") {
+        return { kind: "Unknown" };
+    }
+    if (name === "never") {
+        return { kind: "Never" };
+    }
+    if (name === "buffer" || name === "Buffer") {
+        return { kind: "Buffer" };
+    }
+    if (PRIMITIVE_MAP[name]) {
+        return { kind: "Primitive", name: PRIMITIVE_MAP[name] };
+    }
+    if (/^[A-Z]/.test(name)) {
+        return { kind: "Class", name };
+    }
+    return { kind: "Primitive", name };
+}
+function mapParameter(param, index) {
+    const name = param.Name || `arg${index}`;
+    const type = mapRobloxType(param.Type);
+    const optional = type.kind === "Optional" || param.Default !== undefined;
+    const def = classifyDefault(param.Default);
+    return {
+        name,
+        type: optional && type.kind !== "Optional" ? { kind: "Optional", inner: type } : type,
+        optional,
+        default: param.Default,
+        defaultKind: def,
+    };
+}
+function classifyDefault(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "null" || value === "nil") {
+        return "Null";
+    }
+    if (value === "true" || value === "false") {
+        return "Boolean";
+    }
+    if (/^-?\d+(\.\d+)?$/.test(value)) {
+        return "Number";
+    }
+    if (/^Enum\./.test(value)) {
+        return "EnumItem";
+    }
+    if (/^['"`]/.test(value)) {
+        return "String";
+    }
+    return "Unknown";
+}
+function typeToClpp(type) {
+    switch (type.kind) {
+        case "Primitive":
+            if (type.name === "boolean") {
+                return "bool";
+            }
+            if (type.name === "void") {
+                return "void";
+            }
+            return type.name;
+        case "Class":
+        case "Datatype":
+            return type.name;
+        case "Enum":
+            return `Enum::${type.name}`;
+        case "Optional":
+            return `${typeToClpp(type.inner)}?`;
+        case "Array":
+            return `array<${typeToClpp(type.element)}>`;
+        case "Dictionary":
+        case "Map":
+            return `dictionary<${typeToClpp(type.key)}, ${typeToClpp(type.value)}>`;
+        case "Tuple":
+            return `tuple<${type.elements.map(typeToClpp).join(", ")}>`;
+        case "Function":
+            return "func";
+        case "Union":
+            return type.members.map(typeToClpp).join(" | ");
+        case "Buffer":
+            return "buffer";
+        case "Any":
+            return "auto";
+        case "Unknown":
+            return "auto";
+        case "Never":
+            return "void";
+        case "Unsupported":
+            return "auto";
+        default:
+            return "auto";
+    }
+}
+function typeToLuau(type) {
+    switch (type.kind) {
+        case "Primitive":
+            if (type.name === "int" || type.name === "int64" || type.name === "float" || type.name === "double") {
+                return "number";
+            }
+            if (type.name === "void") {
+                return "()";
+            }
+            return type.name;
+        case "Class":
+        case "Datatype":
+            return type.name;
+        case "Enum":
+            return `Enum.${type.name}`;
+        case "Optional":
+            return `${typeToLuau(type.inner)}?`;
+        case "Array":
+            return `{ ${typeToLuau(type.element)} }`;
+        case "Dictionary":
+        case "Map":
+            return `{ [${typeToLuau(type.key)}]: ${typeToLuau(type.value)} }`;
+        case "Buffer":
+            return "buffer";
+        case "Any":
+            return "any";
+        case "Unknown":
+            return "unknown";
+        case "Function":
+            return "(...any) -> ...any";
+        case "Unsupported":
+            return "any";
+        default:
+            return "any";
+    }
+}
+function eventSignalType(parameters) {
+    return {
+        kind: "Datatype",
+        name: parameters.length
+            ? `RBXScriptSignal/*(${parameters.map((p) => typeToClpp(p.type)).join(", ")})*/`
+            : "RBXScriptSignal",
+    };
+}

package/generated/api/sources/aux-types-diff.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffAgainstAuxTypes = diffAgainstAuxTypes;
+/**
+ * Optional coverage cross-check against @rbxts/types or LuauTypes.
+ * Never imported by the compile hot path.
+ */
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function collectDeclareClasses(text) {
+    const names = new Set();
+    const re = /\b(?:declare\s+class|export\s+type|interface|type)\s+([A-Za-z_][\w]*)/g;
+    let match;
+    while ((match = re.exec(text))) {
+        names.add(match[1]);
+    }
+    return names;
+}
+/**
+ * Diff registry class/datatype/enum names against a local types file or directory
+ * (e.g. node_modules/@rbxts/types or Studio LuauTypes.d.luau).
+ */
+function diffAgainstAuxTypes(registryNames, auxPath) {
+    if (!node_fs_1.default.existsSync(auxPath)) {
+        throw new Error(`Aux types path not found: ${auxPath}`);
+    }
+    const stat = node_fs_1.default.statSync(auxPath);
+    let auxSet;
+    if (stat.isDirectory()) {
+        auxSet = new Set();
+        const stack = [auxPath];
+        while (stack.length) {
+            const dir = stack.pop();
+            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()) {
+                    stack.push(full);
+                }
+                else if (/\.(luau|ts|d\.ts)$/i.test(entry.name)) {
+                    for (const name of collectDeclareClasses(node_fs_1.default.readFileSync(full, "utf8"))) {
+                        auxSet.add(name);
+                    }
+                }
+            }
+        }
+    }
+    else {
+        auxSet = collectDeclareClasses(node_fs_1.default.readFileSync(auxPath, "utf8"));
+    }
+    const regSet = new Set(registryNames);
+    const onlyInAux = [];
+    const onlyInRegistry = [];
+    for (const name of auxSet) {
+        if (!regSet.has(name)) {
+            onlyInAux.push(name);
+        }
+    }
+    for (const name of regSet) {
+        if (!auxSet.has(name)) {
+            onlyInRegistry.push(name);
+        }
+    }
+    onlyInAux.sort();
+    onlyInRegistry.sort();
+    return {
+        source: auxPath,
+        auxSymbols: auxSet.size,
+        registrySymbols: regSet.size,
+        onlyInAux,
+        onlyInRegistry,
+    };
+}

package/generated/api/sources/client-tracker.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadClientTrackerDump = loadClientTrackerDump;
+const loader_js_1 = require("../loader.js");
+/**
+ * Optional Client Tracker adapter (non-authoritative early-diff source).
+ * Pass a local API-Dump.json / Full-API-Dump.json checkout path.
+ */
+function loadClientTrackerDump(filePath) {
+    return (0, loader_js_1.loadJsonFile)("client-tracker", filePath);
+}

package/generated/api/sources/creator-docs.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCreatorDocs = loadCreatorDocs;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const resolver_js_1 = require("../resolver.js");
+/**
+ * Creator Docs engine reference walker.
+ * Expects a local clone of Roblox/creator-docs (or a fixture subtree).
+ */
+function loadCreatorDocs(rootDir) {
+    if (!node_fs_1.default.existsSync(rootDir)) {
+        throw new Error(`Creator Docs root not found: ${rootDir}`);
+    }
+    const pages = [];
+    const stack = [rootDir];
+    while (stack.length) {
+        const dir = stack.pop();
+        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()) {
+                stack.push(full);
+            }
+            else if (/\.(md|mdx|yaml|yml)$/i.test(entry.name)) {
+                pages.push(node_path_1.default.relative(rootDir, full).replace(/\\/g, "/"));
+            }
+        }
+    }
+    pages.sort();
+    return {
+        meta: {
+            id: "creator-docs",
+            path: rootDir,
+            hash: (0, resolver_js_1.hashBuffer)(pages.join("\n")),
+            loadedAt: new Date().toISOString(),
+        },
+        data: { pages },
+    };
+}

package/generated/api/sources/luau-types.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadLuauTypes = loadLuauTypes;
+const node_fs_1 = __importDefault(require("node:fs"));
+const resolver_js_1 = require("../resolver.js");
+/**
+ * Parse LuauTypes.d.luau into a lightweight symbol index.
+ * Full type AST is deferred; we extract declare/class/type names for cross-check.
+ */
+function loadLuauTypes(filePath) {
+    if (!node_fs_1.default.existsSync(filePath)) {
+        throw new Error(`LuauTypes file not found: ${filePath}`);
+    }
+    const raw = node_fs_1.default.readFileSync(filePath);
+    const text = raw.toString("utf8");
+    const symbols = new Set();
+    const declareRe = /\b(?:declare|type|export type|class)\s+([A-Za-z_][\w.]*)/g;
+    let match;
+    while ((match = declareRe.exec(text))) {
+        symbols.add(match[1].split(".")[0]);
+    }
+    return {
+        meta: {
+            id: "luau-types",
+            path: filePath,
+            hash: (0, resolver_js_1.hashBuffer)(raw),
+            loadedAt: new Date().toISOString(),
+        },
+        data: { symbols: [...symbols].sort(), textHash: (0, resolver_js_1.hashBuffer)(raw) },
+    };
+}

package/generated/api/sources/mini-dump.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMiniDump = loadMiniDump;
+const node_path_1 = __importDefault(require("node:path"));
+const package_info_js_1 = require("../../package-info.js");
+const loader_js_1 = require("../loader.js");
+function loadMiniDump(filePath) {
+    const target = filePath || node_path_1.default.join(package_info_js_1.projectRoot, "data", "Mini-API-Dump.json");
+    const loaded = (0, loader_js_1.loadJsonFile)("mini-api-dump", target);
+    if (!Array.isArray(loaded.data.Classes) || !Array.isArray(loaded.data.Enums)) {
+        throw new Error("Mini-API-Dump.json missing Classes/Enums arrays");
+    }
+    return loaded;
+}

package/generated/api/sources/studio-api.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadStudioApi = loadStudioApi;
+const loader_js_1 = require("../loader.js");
+/** Studio --api JSON (same shape family as Mini dump when exported). */
+function loadStudioApi(filePath) {
+    return (0, loader_js_1.loadJsonFile)("studio-api", filePath);
+}

package/generated/api/sources/studio-apiv2.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadStudioApiV2 = loadStudioApiV2;
+const loader_js_1 = require("../loader.js");
+/**
+ * Studio --apiV2 JSON export — preferred canonical schema when available.
+ * Until a fixture is checked in, callers may pass a local Studio dump path.
+ */
+function loadStudioApiV2(filePath) {
+    return (0, loader_js_1.loadJsonFile)("studio-api-v2", filePath);
+}

package/generated/api/sources/studio-full-api.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadStudioFullApi = loadStudioFullApi;
+const loader_js_1 = require("../loader.js");
+/** Studio --fullApi JSON export. */
+function loadStudioFullApi(filePath) {
+    return (0, loader_js_1.loadJsonFile)("studio-full-api", filePath);
+}

package/generated/api/studio-smoke.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME_SUITE = void 0;
+exports.resolveStudioBinary = resolveStudioBinary;
+exports.runStudioSmoke = runStudioSmoke;
+/**
+ * Optional Studio smoke — skip when Studio is absent.
+ * Not a parallel Studio test framework; keep minimal.
+ */
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const package_info_js_1 = require("../package-info.js");
+function resolveStudioBinary() {
+    if (process.env.ROBLOX_STUDIO) {
+        return process.env.ROBLOX_STUDIO;
+    }
+    const candidates = [
+        "C:\\\\Program Files (x86)\\\\Roblox\\\\Versions",
+        "C:\\\\Program Files\\\\Roblox\\\\Versions",
+    ];
+    for (const root of candidates) {
+        if (!node_fs_1.default.existsSync(root)) {
+            continue;
+        }
+        for (const ver of node_fs_1.default.readdirSync(root)) {
+            const exe = node_path_1.default.join(root, ver, "RobloxStudioBeta.exe");
+            if (node_fs_1.default.existsSync(exe)) {
+                return exe;
+            }
+        }
+    }
+    return null;
+}
+const SMOKE_SCRIPT = `
+local ok = true
+local function check(cond, msg)
+	if not cond then
+		ok = false
+		warn("[cluaupp-smoke]", msg)
+	end
+end
+check(typeof(Instance.new("Folder")) == "Instance", "Instance.new Folder")
+check(game:GetService("Players") ~= nil, "GetService Players")
+check(typeof(Vector3.new(1,2,3)) == "Vector3", "Vector3")
+check(Enum.Material.Plastic ~= nil, "Enum.Material")
+check(task.wait ~= nil, "task.wait")
+print(ok and "SMOKE_OK" or "SMOKE_FAIL")
+`;
+function runStudioSmoke() {
+    const studio = resolveStudioBinary();
+    if (!studio) {
+        return { skipped: true, ok: true, output: "Roblox Studio not found; smoke skipped" };
+    }
+    const scriptPath = node_path_1.default.join(package_info_js_1.projectRoot, "test", "studio", "smoke.luau");
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(scriptPath), { recursive: true });
+    node_fs_1.default.writeFileSync(scriptPath, SMOKE_SCRIPT, "utf8");
+    const result = (0, node_child_process_1.spawnSync)(studio, ["--task", "RunScript", scriptPath], {
+        encoding: "utf8",
+        timeout: 120_000,
+    });
+    const output = `${result.stdout || ""}${result.stderr || ""}`;
+    const ok = output.includes("SMOKE_OK") || result.status === 0;
+    return { skipped: false, ok, output };
+}
+exports.RUNTIME_SUITE = [
+    "Instance.new",
+    "GetService",
+    "events",
+    "datatypes",
+    "ModuleScript",
+    "Server",
+    "Client",
+    "enums",
+    "task",
+    "require",
+];

package/generated/api/type-parse.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseClppTypeString = parseClppTypeString;
+exports.mapNamedTypeLike = mapNamedTypeLike;
+/** Parse simple CL++ type strings from override specs (e.g. "Vector3", "Enum::EasingStyle", "double?"). */
+function parseClppTypeString(raw) {
+    const text = String(raw || "").trim();
+    if (!text) {
+        return { kind: "Unknown" };
+    }
+    if (text.endsWith("?")) {
+        return { kind: "Optional", inner: parseClppTypeString(text.slice(0, -1)) };
+    }
+    if (text.endsWith("*")) {
+        return parseClppTypeString(text.slice(0, -1));
+    }
+    const arrayMatch = /^LuaArray<(.+)>$/.exec(text) || /^array<(.+)>$/i.exec(text);
+    if (arrayMatch) {
+        return { kind: "Array", element: parseClppTypeString(arrayMatch[1]) };
+    }
+    if (text.startsWith("Enum::")) {
+        return { kind: "Enum", name: text.slice("Enum::".length) };
+    }
+    if (text === "bool" || text === "boolean") {
+        return { kind: "Primitive", name: "boolean" };
+    }
+    if (text === "void") {
+        return { kind: "Primitive", name: "void" };
+    }
+    if (text === "string" || text === "int" || text === "int64" || text === "float" || text === "double" || text === "long long") {
+        if (text === "long long") {
+            return { kind: "Primitive", name: "int64" };
+        }
+        return { kind: "Primitive", name: text };
+    }
+    if (text === "buffer") {
+        return { kind: "Buffer" };
+    }
+    if (text === "auto" || text === "any") {
+        return { kind: "Any" };
+    }
+    if (/^[A-Z]/.test(text)) {
+        return { kind: "Datatype", name: text };
+    }
+    return { kind: "Primitive", name: text };
+}
+function mapNamedTypeLike(name) {
+    return parseClppTypeString(name);
+}

package/generated/api/understander.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTENT_RULES = void 0;
+exports.matchIntents = matchIntents;
+exports.understandSymbol = understandSymbol;
+const ide_js_1 = require("./ide.js");
+exports.INTENT_RULES = [
+    {
+        id: "instance-new",
+        kind: "create-instance",
+        pattern: /\bInstance\s*\.\s*new\b|\bnew\s+[A-Z]\w+\s*\(/,
+        description: "Construct a Roblox Instance",
+    },
+    {
+        id: "get-service",
+        kind: "get-service",
+        pattern: /\bGetService\s*[<(]/,
+        description: "Resolve a service via GetService",
+    },
+    {
+        id: "connect-event",
+        kind: "connect-event",
+        pattern: /\.\s*Connect\s*\(/,
+        description: "Connect to an RBXScriptSignal",
+    },
+    {
+        id: "require",
+        kind: "require-module",
+        pattern: /\brequire\s*\(/,
+        description: "Require a ModuleScript / library",
+    },
+];
+function matchIntents(source) {
+    return exports.INTENT_RULES.filter((rule) => rule.pattern.test(source));
+}
+function understandSymbol(symbol, registry) {
+    const reg = registry || (0, ide_js_1.getApiRegistry)();
+    if (reg.classes.has(symbol)) {
+        return { registryHit: true, kind: "class", intents: [] };
+    }
+    if (reg.services.has(symbol)) {
+        return { registryHit: true, kind: "service", intents: ["get-service"] };
+    }
+    if (reg.enums.has(symbol)) {
+        return { registryHit: true, kind: "enum", intents: [] };
+    }
+    if (reg.datatypes.has(symbol)) {
+        return { registryHit: true, kind: "datatype", intents: [] };
+    }
+    return { registryHit: false, intents: [] };
+}