cluaupp 0.1.4 → 0.2.0

package/generated/parser/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCppParserSync = createCppParserSync;
+exports.parseCpp = parseCpp;
+const tree_sitter_1 = __importDefault(require("tree-sitter"));
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const package_info_js_1 = require("../package-info.js");
+const nodeRequire = (0, node_module_1.createRequire)(node_path_1.default.join(package_info_js_1.projectRoot, "package.json"));
+function createCppParserSync() {
+    try {
+        const Cpp = nodeRequire("tree-sitter-cpp");
+        const parser = new tree_sitter_1.default();
+        parser.setLanguage(Cpp);
+        parser.parse("int main() { return 0; }");
+        return parser;
+    }
+    catch {
+        return null;
+    }
+}
+function parseCpp(source, parser = createCppParserSync()) {
+    if (!parser) {
+        return null;
+    }
+    return parser.parse(source);
+}

package/generated/preprocess.js

@@ -0,0 +1,181 @@
+"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.isHeaderFile = isHeaderFile;
+exports.toLuauPath = toLuauPath;
+exports.isEngineStub = isEngineStub;
+exports.siblingImplementation = siblingImplementation;
+exports.siblingHeader = siblingHeader;
+exports.implOutName = implOutName;
+exports.resolveInclude = resolveInclude;
+exports.scanHeaderExports = scanHeaderExports;
+exports.applyPragmas = applyPragmas;
+exports.preprocess = preprocess;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.SOURCE_EXTS = [".cpp", ".cc", ".cxx", ".c", ".h", ".hpp", ".hh"];
+function isSourceFile(fileName) {
+    return exports.SOURCE_EXTS.includes(node_path_1.default.extname(fileName).toLowerCase());
+}
+function isHeaderFile(fileName) {
+    return [".h", ".hpp", ".hh"].includes(node_path_1.default.extname(fileName).toLowerCase());
+}
+function toLuauPath(filePath) {
+    return filePath.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
+}
+function isEngineStub(filePath) {
+    const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+    return (normalized.includes("/include/cluaupp/") ||
+        normalized.includes("/include/cluau/") ||
+        normalized.endsWith("/roblox.hpp") ||
+        normalized.endsWith("/roblox.h"));
+}
+function includeVariants(name) {
+    const variants = [name];
+    if (/\.h$/i.test(name)) {
+        variants.push(name.replace(/\.h$/i, ".hpp"), name.replace(/\.h$/i, ".hh"));
+    }
+    else if (/\.hpp$/i.test(name)) {
+        variants.push(name.replace(/\.hpp$/i, ".h"), name.replace(/\.hpp$/i, ".hh"));
+    }
+    else if (/\.hh$/i.test(name)) {
+        variants.push(name.replace(/\.hh$/i, ".h"), name.replace(/\.hh$/i, ".hpp"));
+    }
+    return [...new Set(variants)];
+}
+function siblingImplementation(headerPath) {
+    if (!headerPath || !isHeaderFile(headerPath)) {
+        return null;
+    }
+    const base = headerPath.replace(/\.(h|hpp|hh)$/i, "");
+    for (const ext of [".cpp", ".cc", ".cxx", ".c"]) {
+        if (node_fs_1.default.existsSync(base + ext)) {
+            return base + ext;
+        }
+    }
+    return null;
+}
+function siblingHeader(implPath) {
+    if (!implPath || isHeaderFile(implPath)) {
+        return null;
+    }
+    const base = String(implPath).replace(/\.(cpp|cc|cxx|c)$/i, "");
+    if (base === String(implPath)) {
+        return null;
+    }
+    for (const ext of [".h", ".hpp", ".hh"]) {
+        if (node_fs_1.default.existsSync(base + ext)) {
+            return base + ext;
+        }
+    }
+    return null;
+}
+function implOutName(rel) {
+    return String(rel)
+        .replace(/\\/g, "/")
+        .replace(/\.(cpp|cc|cxx|c)$/i, "Impl.luau");
+}
+function resolveInclude(name, fromFile, includeDirs) {
+    const bases = [node_path_1.default.dirname(fromFile), ...(includeDirs || [])];
+    for (const base of bases) {
+        for (const variant of includeVariants(name)) {
+            const candidate = node_path_1.default.resolve(base, variant);
+            if (node_fs_1.default.existsSync(candidate) && node_fs_1.default.statSync(candidate).isFile()) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+function scanHeaderExports(source) {
+    const consts = [];
+    const structs = [];
+    for (const match of String(source).matchAll(/\bconst\s+(?:int|bool|float|double|auto|string)\s+(\w+)/g)) {
+        if (!consts.includes(match[1])) {
+            consts.push(match[1]);
+        }
+    }
+    for (const match of String(source).matchAll(/\bstruct\s+(\w+)/g)) {
+        if (!structs.includes(match[1])) {
+            structs.push(match[1]);
+        }
+    }
+    const hasProtos = /\b(?:void|int|bool|float|double|auto|string|[\w:]+)\s+\w+\s*\([^;]*\)\s*;/.test(String(source));
+    return { consts, structs, hasProtos };
+}
+function pushModuleInclude(options, resolved, impl) {
+    options.moduleIncludes = options.moduleIncludes || [];
+    const srcDir = options.srcDir || null;
+    const moduleFile = impl || resolved;
+    const rel = srcDir ? node_path_1.default.relative(srcDir, moduleFile).replace(/\\/g, "/") : node_path_1.default.basename(moduleFile);
+    const headerText = node_fs_1.default.readFileSync(resolved, "utf8");
+    options.moduleIncludes.push({
+        name: node_path_1.default.basename(resolved).replace(/\.(h|hpp|hh)$/i, ""),
+        outRel: rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau"),
+        header: resolved,
+        impl: impl || null,
+        exports: scanHeaderExports(headerText),
+    });
+}
+function applyPragmas(source, options) {
+    let nstrict = false;
+    let strict = false;
+    for (const line of String(source).split(/\r?\n/)) {
+        if (/^\s*#\s*pragma\s+nstrict\b/i.test(line)) {
+            nstrict = true;
+        }
+        else if (/^\s*#\s*pragma\s+strict\b/i.test(line)) {
+            strict = true;
+        }
+    }
+    if (nstrict) {
+        options.strict = false;
+    }
+    else if (strict) {
+        options.strict = true;
+    }
+}
+function preprocess(source, filePath, options = {}) {
+    if (!options.pragmaResolved) {
+        options.pragmaResolved = true;
+        applyPragmas(source, options);
+    }
+    const seen = options.seen || new Set();
+    options.seen = seen;
+    const includeDirs = options.includeDirs || [];
+    const resolvedSelf = filePath ? node_path_1.default.resolve(filePath) : null;
+    if (resolvedSelf) {
+        seen.add(resolvedSelf);
+    }
+    const lines = String(source).split(/\r?\n/);
+    const out = [];
+    for (const line of lines) {
+        const quoted = line.match(/^\s*#\s*include\s+"([^"]+)"/);
+        if (quoted) {
+            const resolved = resolveInclude(quoted[1], filePath || process.cwd(), includeDirs);
+            if (!resolved || isEngineStub(resolved) || seen.has(resolved)) {
+                continue;
+            }
+            const impl = siblingImplementation(resolved);
+            const including = filePath ? node_path_1.default.resolve(filePath) : null;
+            const ownHeader = Boolean(impl && including && node_path_1.default.resolve(impl) === including);
+            if (!ownHeader) {
+                pushModuleInclude(options, resolved, impl);
+                continue;
+            }
+            seen.add(resolved);
+            const inner = node_fs_1.default.readFileSync(resolved, "utf8");
+            out.push(preprocess(inner, resolved, { ...options, seen }));
+            continue;
+        }
+        if (/^\s*#\s*include\s+</.test(line)) {
+            continue;
+        }
+        out.push(line);
+    }
+    return out.join("\n");
+}

package/generated/system-understander.js

@@ -0,0 +1,443 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTENTS = void 0;
+exports.walk = walk;
+exports.namesIn = namesIn;
+exports.parseFileTag = parseFileTag;
+exports.scoreIntents = scoreIntents;
+exports.determineArchitecture = determineArchitecture;
+exports.understandSystem = understandSystem;
+const node_path_1 = __importDefault(require("node:path"));
+const EXT = "(cpp|cc|cxx|c|h|hpp|hh)";
+const EXT_REGEX = new RegExp(`\\.${EXT}$`, "i");
+const SCORE_THRESHOLD = 2;
+const TREE_NAME_TYPES = new Set([
+    "identifier",
+    "field_identifier",
+    "type_identifier",
+    "namespace_identifier",
+]);
+const ROBLOX_SERVICES = new Set([
+    "Players",
+    "Workspace",
+    "Lighting",
+    "ReplicatedStorage",
+    "ReplicatedFirst",
+    "ServerStorage",
+    "ServerScriptService",
+    "StarterGui",
+    "StarterPack",
+    "StarterPlayer",
+    "SoundService",
+    "TweenService",
+    "RunService",
+    "UserInputService",
+    "ContextActionService",
+    "GuiService",
+    "TextChatService",
+    "TextService",
+    "CollectionService",
+    "PhysicsService",
+    "PathfindingService",
+    "DataStoreService",
+    "MemoryStoreService",
+    "MessagingService",
+    "TeleportService",
+    "HttpService",
+    "MarketplaceService",
+    "BadgeService",
+    "PolicyService",
+    "ProximityPromptService",
+    "HapticService",
+    "VRService",
+    "GamepadService",
+    "TouchInputService",
+    "VoiceChatService",
+    "AnimationClipProvider",
+    "AssetService",
+    "AvatarEditorService",
+    "Chat",
+    "Debris",
+    "InsertService",
+    "JointsService",
+    "KeyframeSequenceProvider",
+    "LocalizationService",
+    "LogService",
+    "MaterialService",
+    "NotificationService",
+    "PointsService",
+    "SocialService",
+    "Stats",
+    "Teams",
+    "TestService",
+    "TimerService",
+]);
+/**
+ * Filename key first (roblox-ts ScriptType), then AST token density
+ * (Knit/Flamework Service vs Controller naming).
+ * @see https://github.com/roblox-ts/roblox-ts
+ * @see https://github.com/roblox-csharp/roblox-cs
+ * @see https://create.roblox.com/docs/reference/engine
+ */
+exports.INTENTS = {
+    players: {
+        role: "manager",
+        module: "PlayersManager",
+        side: "server",
+        tokens: ["GetPlayers", "PlayerAdded", "PlayerRemoving", "Players"],
+    },
+    cache: {
+        role: "controller",
+        module: "CacheController",
+        side: "server",
+        tokens: ["Folder", "IntValue", "StringValue", "BoolValue", "NumberValue", "leaderstats"],
+    },
+    combat: {
+        role: "controller",
+        module: "CombatController",
+        side: "server",
+        tokens: [
+            "TakeDamage",
+            "Humanoid",
+            "Raycast",
+            "RaycastParams",
+            "Hitbox",
+            "Health",
+            "Damage",
+            "Weapon",
+            "Tool",
+            "Activated",
+            "Combat",
+            "Hurt",
+            "Attack",
+        ],
+    },
+    character: {
+        role: "controller",
+        module: "CharacterController",
+        side: "any",
+        tokens: ["CharacterAdded", "CharacterRemoving", "HumanoidRootPart", "GetPivot", "PivotTo", "Character"],
+    },
+    input: {
+        role: "controller",
+        module: "InputController",
+        side: "client",
+        tokens: [
+            "UserInputService",
+            "ContextActionService",
+            "InputBegan",
+            "InputEnded",
+            "InputChanged",
+            "Mouse",
+            "GetMouse",
+            "PreferredInput",
+            "GamepadService",
+            "TouchInputService",
+        ],
+    },
+    ui: {
+        role: "controller",
+        module: "ViewController",
+        side: "client",
+        tokens: [
+            "PlayerGui",
+            "ScreenGui",
+            "BillboardGui",
+            "SurfaceGui",
+            "TextLabel",
+            "TextButton",
+            "Frame",
+            "ImageLabel",
+            "TweenService",
+            "Twinkle",
+            "GuiService",
+            "StarterGui",
+        ],
+    },
+    net: {
+        role: "controller",
+        module: "NetController",
+        side: "any",
+        tokens: [
+            "RemoteEvent",
+            "RemoteFunction",
+            "UnreliableRemoteEvent",
+            "FireServer",
+            "FireAllClients",
+            "FireClient",
+            "OnServerEvent",
+            "OnClientEvent",
+            "Net",
+            "NetEvent",
+        ],
+    },
+    data: {
+        role: "service",
+        module: "DataController",
+        side: "server",
+        tokens: [
+            "DataStore",
+            "DataStoreService",
+            "DataService",
+            "SetAsync",
+            "GetAsync",
+            "UpdateAsync",
+            "ProfileStore",
+            "GetChangedSignal",
+            "WaitFor",
+            "MemoryStoreService",
+            "MessagingService",
+        ],
+    },
+    animation: {
+        role: "controller",
+        module: "AnimationController",
+        side: "any",
+        tokens: ["Animator", "Animation", "AnimationTrack", "LoadAnimation"],
+    },
+    inventory: {
+        role: "handler",
+        module: "InventoryHandler",
+        side: "any",
+        tokens: ["Backpack", "Inventory"],
+    },
+    marketplace: {
+        role: "service",
+        module: "MarketplaceService",
+        side: "server",
+        tokens: ["MarketplaceService", "PromptGamePassPurchase", "PromptProductPurchase", "ProcessReceipt"],
+    },
+    collection: {
+        role: "manager",
+        module: "CollectionManager",
+        side: "shared",
+        tokens: ["CollectionService", "GetTagged", "AddTag", "RemoveTag", "GetInstanceAddedSignal"],
+    },
+    proximity: {
+        role: "handler",
+        module: "ProximityHandler",
+        side: "any",
+        tokens: ["ProximityPrompt", "ProximityPromptService", "Triggered"],
+    },
+    camera: {
+        role: "controller",
+        module: "CameraController",
+        side: "client",
+        tokens: ["CurrentCamera", "Camera", "CameraType", "CameraSubject"],
+    },
+    run: {
+        role: "utility",
+        module: "HeartbeatUtil",
+        side: "any",
+        tokens: ["RunService", "Heartbeat", "RenderStepped", "Stepped", "PreSimulation"],
+    },
+};
+function isTreeNode(node) {
+    return Boolean(node &&
+        typeof node === "object" &&
+        "childCount" in node &&
+        typeof node.child === "function");
+}
+function walk(node, visit) {
+    if (!node || typeof node !== "object") {
+        return;
+    }
+    visit(node);
+    if (isTreeNode(node) && typeof node.childCount === "number" && node.child) {
+        for (let index = 0; index < node.childCount; index += 1) {
+            const child = node.child(index);
+            if (child) {
+                walk(child, visit);
+            }
+        }
+        return;
+    }
+    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 addName(found, value) {
+    if (typeof value !== "string") {
+        return;
+    }
+    const trimmed = value.replace(/^["'<]+|["'>]+$/g, "").trim();
+    if (trimmed) {
+        found.add(trimmed);
+    }
+}
+function namesIn(ast, options = {}) {
+    const found = new Set();
+    walk(ast, (node) => {
+        const type = String(node.type || "");
+        if ((type === "call" || type === "member" || type === "ident") && node.name) {
+            addName(found, node.name);
+        }
+        if (type === "new" && node.className) {
+            addName(found, node.className);
+        }
+        if (type === "getService" && node.service) {
+            addName(found, node.service);
+        }
+        if (options.strings !== false && type === "string" && node.value) {
+            addName(found, node.value);
+        }
+        if (TREE_NAME_TYPES.has(type) && typeof node.text === "string") {
+            addName(found, node.text);
+        }
+        if (options.strings !== false && type === "string_literal" && typeof node.text === "string") {
+            addName(found, node.text);
+        }
+    });
+    return found;
+}
+function parseFileTag(fileName) {
+    const base = node_path_1.default.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 sideWeight(runtime, side) {
+    if (side === "any" || side === "shared") {
+        return 1;
+    }
+    if (side === runtime) {
+        return 1.25;
+    }
+    if (runtime === "shared") {
+        return 0.6;
+    }
+    return 0.35;
+}
+function scoreIntents(namedSet, runtime = "shared") {
+    const scored = [];
+    for (const [name, spec] of Object.entries(exports.INTENTS)) {
+        const evidence = spec.tokens.filter((token) => namedSet.has(token));
+        if (evidence.length === 0) {
+            continue;
+        }
+        scored.push({
+            name,
+            score: evidence.length * sideWeight(runtime, spec.side),
+            evidence,
+            role: spec.role,
+            module: spec.module,
+            side: spec.side,
+        });
+    }
+    return scored.sort((a, b) => b.score - a.score || b.evidence.length - a.evidence.length);
+}
+function pascalUtilName(fileName) {
+    let base = node_path_1.default.basename(fileName).replace(EXT_REGEX, "");
+    base = base.replace(/\.legacy\.(server|client|plugin)$/i, "");
+    base = base.replace(/\.(server|client|plugin)$/i, "");
+    if (!base) {
+        return "ModuleUtil";
+    }
+    const pascal = base
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+    return /Util$/.test(pascal) ? pascal : `${pascal}Util`;
+}
+function collectInjectedServices(named, evidence) {
+    const found = new Set();
+    for (const token of [...evidence, ...named]) {
+        if (ROBLOX_SERVICES.has(token)) {
+            found.add(token);
+        }
+    }
+    return [...found].sort();
+}
+const SUPPORTING_INTENTS = new Set(["players", "cache", "run"]);
+function pickDominant(intents) {
+    const top = intents[0];
+    if (!top) {
+        return undefined;
+    }
+    const domain = intents.find((item) => !SUPPORTING_INTENTS.has(item.name) && item.evidence.length >= SCORE_THRESHOLD);
+    if (domain && (SUPPORTING_INTENTS.has(top.name) || domain.score >= top.score * 0.8)) {
+        return domain;
+    }
+    return top;
+}
+function formatIntents(intents) {
+    return intents.map((item) => `${item.name}:${item.evidence.length}`).join(", ");
+}
+function determineArchitecture(fileName, ast, tree) {
+    const fileTag = parseFileTag(fileName);
+    const named = new Set();
+    if (ast) {
+        for (const name of namesIn(ast)) {
+            named.add(name);
+        }
+    }
+    if (tree) {
+        for (const name of namesIn(tree)) {
+            named.add(name);
+        }
+    }
+    const intents = scoreIntents(named, fileTag.runtime);
+    const top = pickDominant(intents);
+    if (!top || top.score < SCORE_THRESHOLD) {
+        const suggestedModule = pascalUtilName(fileName);
+        return {
+            role: "utility",
+            suggestedModule,
+            fileTag,
+            injectedServices: collectInjectedServices(named, top ? top.evidence : []),
+            isUtility: true,
+            intents,
+            reasoning: [
+                `tag ${fileTag.key} → ${fileTag.rojo} (${fileTag.emit})`,
+                top ? `intents ${formatIntents(intents)} below threshold` : "intents none — utility module",
+                `role utility ${suggestedModule}`,
+            ],
+        };
+    }
+    return {
+        role: top.role,
+        suggestedModule: top.module,
+        fileTag,
+        injectedServices: collectInjectedServices(named, top.evidence),
+        isUtility: false,
+        intents,
+        reasoning: [
+            `tag ${fileTag.key} → ${fileTag.rojo} (${fileTag.emit})`,
+            `intents ${formatIntents(intents)}`,
+            `role ${top.role} ${top.module}`,
+        ],
+    };
+}
+function understandSystem(fileName, ast, tree) {
+    return determineArchitecture(fileName, ast, tree);
+}