dominus-cli 0.1.0

package/plugin/src/Properties.lua

@@ -0,0 +1,424 @@
+--[[
+	Properties module: read/write instance properties
+	Uses ReflectionService to determine expected types for smart coercion.
+]]
+
+local Explorer = require(script.Parent.Explorer)
+local ReflectionService = game:GetService("ReflectionService")
+
+local Properties = {}
+
+local IGNORED_PROPERTIES = {
+	Parent = true,
+	ClassName = true,
+	Archivable = true,
+}
+
+-- Cache property type maps per class to avoid repeated reflection calls
+local typeCache = {}
+
+local function getPropertyTypeMap(className)
+	if typeCache[className] then return typeCache[className] end
+
+	local typeMap = {}
+	local ok, props = pcall(function()
+		return ReflectionService:GetPropertiesOfClass(className)
+	end)
+	if ok and props then
+		for _, prop in props do
+			if prop.ValueType then
+				typeMap[prop.Name] = tostring(prop.ValueType)
+			end
+		end
+	end
+	typeCache[className] = typeMap
+	return typeMap
+end
+
+function Properties.get(path)
+	local instance = Explorer.resolveInstance(path)
+	if not instance then
+		return { success = false, error = "Instance not found: " .. path }
+	end
+
+	local properties = {}
+
+	local ok, apiData = pcall(function()
+		local info = {}
+		local propData = ReflectionService:GetPropertiesOfClass(instance.ClassName)
+		for _, prop in propData do
+			if not IGNORED_PROPERTIES[prop.Name] then
+				local valueOk, value = pcall(function()
+					return instance[prop.Name]
+				end)
+				if valueOk then
+					table.insert(info, {
+						name = prop.Name,
+						value = tostring(value),
+						type = prop.ValueType and tostring(prop.ValueType) or typeof(value),
+						category = prop.Category or "Other",
+					})
+				end
+			end
+		end
+		return info
+	end)
+
+	if ok then
+		properties = apiData
+	else
+		local commonProps = {"Name", "Position", "Size", "Color", "Material", "Transparency", "Anchored", "CanCollide"}
+		for _, propName in commonProps do
+			local valOk, val = pcall(function()
+				return instance[propName]
+			end)
+			if valOk and val ~= nil then
+				table.insert(properties, {
+					name = propName,
+					value = tostring(val),
+					type = typeof(val),
+				})
+			end
+		end
+	end
+
+	return { properties = properties }
+end
+
+--[[
+	Smart type coercion: converts JSON-friendly values into Roblox types.
+	Uses the expected property type from ReflectionService when available.
+]]
+local function coerceValue(instance, key, value)
+	local expectedType = nil
+	local typeMap = getPropertyTypeMap(instance.ClassName)
+	expectedType = typeMap[key]
+
+	-- If we don't know the expected type, try reading the current value
+	if not expectedType then
+		local curOk, curVal = pcall(function() return instance[key] end)
+		if curOk and curVal ~= nil then
+			expectedType = typeof(curVal)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- UDim2 (GUI Size, Position, etc.)
+	-- ═══════════════════════════════════════════
+	if expectedType == "UDim2" then
+		if type(value) == "table" then
+			-- {xScale, xOffset, yScale, yOffset} or named keys
+			if value.XScale or value.xScale or value.X then
+				return UDim2.new(
+					value.XScale or value.xScale or value.X and value.X.Scale or 0,
+					value.XOffset or value.xOffset or value.X and value.X.Offset or 0,
+					value.YScale or value.yScale or value.Y and value.Y.Scale or 0,
+					value.YOffset or value.yOffset or value.Y and value.Y.Offset or 0
+				)
+			end
+			-- {X = {Scale, Offset}, Y = {Scale, Offset}}
+			if value.X and type(value.X) == "table" then
+				return UDim2.new(
+					value.X.Scale or value.X[1] or 0,
+					value.X.Offset or value.X[2] or 0,
+					value.Y and (value.Y.Scale or value.Y[1]) or 0,
+					value.Y and (value.Y.Offset or value.Y[2]) or 0
+				)
+			end
+			-- Array: {xScale, xOffset, yScale, yOffset}
+			if value[1] ~= nil then
+				return UDim2.new(value[1] or 0, value[2] or 0, value[3] or 0, value[4] or 0)
+			end
+			-- fromScale shorthand: {scale_x, scale_y} when only 2 elements
+			return UDim2.new(0, 0, 0, 0)
+		end
+		if type(value) == "string" then
+			-- "0.5, 0, 0.5, 0" format
+			local a, b, c, d = value:match("([%d%.%-]+)%s*,%s*([%d%.%-]+)%s*,%s*([%d%.%-]+)%s*,%s*([%d%.%-]+)")
+			if a then return UDim2.new(tonumber(a), tonumber(b), tonumber(c), tonumber(d)) end
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- UDim
+	-- ═══════════════════════════════════════════
+	if expectedType == "UDim" then
+		if type(value) == "table" then
+			return UDim.new(value.Scale or value[1] or 0, value.Offset or value[2] or 0)
+		end
+		if type(value) == "number" then
+			return UDim.new(value, 0)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- Vector3
+	-- ═══════════════════════════════════════════
+	if expectedType == "Vector3" then
+		if type(value) == "table" then
+			return Vector3.new(
+				value.X or value.x or value[1] or 0,
+				value.Y or value.y or value[2] or 0,
+				value.Z or value.z or value[3] or 0
+			)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- Vector2
+	-- ═══════════════════════════════════════════
+	if expectedType == "Vector2" then
+		if type(value) == "table" then
+			return Vector2.new(
+				value.X or value.x or value[1] or 0,
+				value.Y or value.y or value[2] or 0
+			)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- Color3
+	-- ═══════════════════════════════════════════
+	if expectedType == "Color3" then
+		if type(value) == "string" then
+			if value:sub(1, 1) == "#" then
+				return Color3.fromHex(value)
+			end
+			if value:match("^rgb") then
+				local r, g, b = value:match("(%d+)%D+(%d+)%D+(%d+)")
+				if r then return Color3.fromRGB(tonumber(r), tonumber(g), tonumber(b)) end
+			end
+			local ok, bc = pcall(BrickColor.new, value)
+			if ok then return bc.Color end
+		end
+		if type(value) == "table" then
+			-- {R, G, B} 0-1 or {r, g, b}
+			if value.R or value.r then
+				return Color3.new(value.R or value.r or 0, value.G or value.g or 0, value.B or value.b or 0)
+			end
+			-- {red, green, blue} 0-255
+			if value.red or value.Red then
+				return Color3.fromRGB(value.red or value.Red or 0, value.green or value.Green or 0, value.blue or value.Blue or 0)
+			end
+			-- Array [r, g, b]
+			if value[1] then
+				if value[1] > 1 or value[2] > 1 or value[3] > 1 then
+					return Color3.fromRGB(value[1], value[2], value[3])
+				end
+				return Color3.new(value[1], value[2], value[3])
+			end
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- BrickColor
+	-- ═══════════════════════════════════════════
+	if expectedType == "BrickColor" then
+		if type(value) == "string" then
+			return BrickColor.new(value)
+		end
+		if type(value) == "number" then
+			return BrickColor.new(value)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- CFrame
+	-- ═══════════════════════════════════════════
+	if expectedType == "CFrame" then
+		if type(value) == "table" then
+			if value.Position or value.position then
+				local pos = value.Position or value.position
+				local cf = CFrame.new(pos.x or pos.X or pos[1] or 0, pos.y or pos.Y or pos[2] or 0, pos.z or pos.Z or pos[3] or 0)
+				if value.Rotation or value.rotation then
+					local rot = value.Rotation or value.rotation
+					cf = cf * CFrame.Angles(
+						math.rad(rot.x or rot.X or rot[1] or 0),
+						math.rad(rot.y or rot.Y or rot[2] or 0),
+						math.rad(rot.z or rot.Z or rot[3] or 0)
+					)
+				end
+				return cf
+			end
+			-- Simple {x, y, z}
+			if value[1] then
+				return CFrame.new(value[1], value[2] or 0, value[3] or 0)
+			end
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- Rect (for GUI ImageRectOffset, etc.)
+	-- ═══════════════════════════════════════════
+	if expectedType == "Rect" then
+		if type(value) == "table" then
+			return Rect.new(value[1] or value.Min and value.Min[1] or 0, value[2] or value.Min and value.Min[2] or 0,
+				value[3] or value.Max and value.Max[1] or 0, value[4] or value.Max and value.Max[2] or 0)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- NumberRange
+	-- ═══════════════════════════════════════════
+	if expectedType == "NumberRange" then
+		if type(value) == "table" then
+			return NumberRange.new(value.Min or value[1] or 0, value.Max or value[2] or 1)
+		end
+		if type(value) == "number" then
+			return NumberRange.new(value)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- NumberSequence (for transparency gradients, etc.)
+	-- ═══════════════════════════════════════════
+	if expectedType == "NumberSequence" then
+		if type(value) == "table" then
+			if value[1] and type(value[1]) == "table" then
+				local keypoints = {}
+				for _, kp in value do
+					table.insert(keypoints, NumberSequenceKeypoint.new(kp.Time or kp[1] or 0, kp.Value or kp[2] or 0, kp.Envelope or kp[3] or 0))
+				end
+				return NumberSequence.new(keypoints)
+			end
+			if #value == 2 and type(value[1]) == "number" then
+				return NumberSequence.new(value[1], value[2])
+			end
+		end
+		if type(value) == "number" then
+			return NumberSequence.new(value)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- ColorSequence
+	-- ═══════════════════════════════════════════
+	if expectedType == "ColorSequence" then
+		if type(value) == "table" then
+			if value[1] and type(value[1]) == "table" then
+				local keypoints = {}
+				for _, kp in value do
+					local color = Color3.new(1, 1, 1)
+					if kp.Color then
+						if type(kp.Color) == "string" and kp.Color:sub(1,1) == "#" then
+							color = Color3.fromHex(kp.Color)
+						elseif type(kp.Color) == "table" then
+							color = Color3.new(kp.Color[1] or 0, kp.Color[2] or 0, kp.Color[3] or 0)
+						end
+					end
+					table.insert(keypoints, ColorSequenceKeypoint.new(kp.Time or kp[1] or 0, color))
+				end
+				return ColorSequence.new(keypoints)
+			end
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- Font
+	-- ═══════════════════════════════════════════
+	if expectedType == "Font" then
+		if type(value) == "table" then
+			local family = value.Family or value.family or "rbxasset://fonts/families/SourceSansPro.json"
+			local weight = Enum.FontWeight.Regular
+			local style = Enum.FontStyle.Normal
+			if value.Weight or value.weight then
+				pcall(function() weight = Enum.FontWeight[value.Weight or value.weight] end)
+			end
+			if value.Style or value.style then
+				pcall(function() style = Enum.FontStyle[value.Style or value.style] end)
+			end
+			return Font.new(family, weight, style)
+		end
+		if type(value) == "string" then
+			return Font.new(value)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- EnumItem (any enum property)
+	-- ═══════════════════════════════════════════
+	if type(value) == "string" then
+		local currentVal = nil
+		pcall(function() currentVal = instance[key] end)
+		if typeof(currentVal) == "EnumItem" then
+			local enumType = tostring(currentVal.EnumType)
+			local enumOk, enumVal = pcall(function()
+				return Enum[enumType][value]
+			end)
+			if enumOk then return enumVal end
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- Fallback: type-agnostic guesses (no expectedType known)
+	-- ═══════════════════════════════════════════
+	if type(value) == "table" and not expectedType then
+		-- UDim2 guess: has XScale/YScale keys
+		if value.XScale or value.xScale then
+			return UDim2.new(
+				value.XScale or value.xScale or 0, value.XOffset or value.xOffset or 0,
+				value.YScale or value.yScale or 0, value.YOffset or value.yOffset or 0
+			)
+		end
+		-- Vector3 guess: 3 number elements or X/Y/Z keys
+		if (value.X or value.x) and (value.Y or value.y) and (value.Z or value.z) then
+			return Vector3.new(value.X or value.x, value.Y or value.y, value.Z or value.z)
+		end
+		if value[1] and value[2] and value[3] and not value[4] then
+			return Vector3.new(value[1], value[2], value[3])
+		end
+		-- Color3 guess: R/G/B keys
+		if value.R or value.r then
+			return Color3.new(value.R or value.r or 0, value.G or value.g or 0, value.B or value.b or 0)
+		end
+		-- Vector2 guess: 2 number elements
+		if value[1] and value[2] and not value[3] then
+			return Vector2.new(value[1], value[2])
+		end
+	end
+
+	-- String-based color on color properties (fallback)
+	if type(value) == "string" and (key == "Color" or key == "Color3" or key:match("Color$")) then
+		if value:sub(1, 1) == "#" then
+			return Color3.fromHex(value)
+		end
+		local ok, bc = pcall(BrickColor.new, value)
+		if ok then return bc.Color end
+	end
+
+	if type(value) == "string" and key == "BrickColor" then
+		return BrickColor.new(value)
+	end
+
+	return value
+end
+
+function Properties.set(path, propertiesToSet)
+	local instance = Explorer.resolveInstance(path)
+	if not instance then
+		return { success = false, error = "Instance not found: " .. path }
+	end
+
+	local errors = {}
+	local set = {}
+
+	for key, value in propertiesToSet do
+		local coerced = coerceValue(instance, key, value)
+		local ok, err = pcall(function()
+			instance[key] = coerced
+		end)
+		if ok then
+			table.insert(set, key)
+		else
+			table.insert(errors, key .. ": " .. tostring(err))
+		end
+	end
+
+	if #errors > 0 then
+		return { success = false, error = table.concat(errors, "; "), set = set }
+	end
+
+	return { success = true, set = set }
+end
+
+return Properties

package/plugin/src/Protocol.lua

@@ -0,0 +1,30 @@
+--[[
+	Message protocol: JSON encoding/decoding with unique ID generation
+]]
+
+local HttpService = game:GetService("HttpService")
+
+local Protocol = {}
+
+function Protocol.encode(data)
+	return HttpService:JSONEncode(data)
+end
+
+function Protocol.decode(json)
+	return HttpService:JSONDecode(json)
+end
+
+function Protocol.generateId()
+	return HttpService:GenerateGUID(false)
+end
+
+function Protocol.createMessage(msgType, payload)
+	return {
+		id = Protocol.generateId(),
+		type = msgType,
+		payload = payload,
+		ts = os.clock(),
+	}
+end
+
+return Protocol

package/plugin/src/Reflection.lua

@@ -0,0 +1,137 @@
+--[[
+	Reflection module: query Roblox class/property/method/event information
+	Uses the new ReflectionService API (2025+):
+	  - GetClass(className, filter?)
+	  - GetClasses(filter?)
+	  - GetPropertiesOfClass(className, filter?)
+	  - GetMethodsOfClass(className, filter?)
+	  - GetEventsOfClass(className, filter?)
+]]
+
+local ReflectionService = game:GetService("ReflectionService")
+local Reflection = {}
+
+local function safeCall(fn, ...)
+	local ok, result = pcall(fn, ...)
+	if ok then return result end
+	return nil, result
+end
+
+function Reflection.getClassInfo(className)
+	local classData, classErr = safeCall(function()
+		return ReflectionService:GetClass(className)
+	end)
+
+	local properties = {}
+	local propData = safeCall(function()
+		return ReflectionService:GetPropertiesOfClass(className)
+	end)
+	if propData then
+		for _, prop in propData do
+			table.insert(properties, {
+				name = prop.Name,
+				type = prop.ValueType and tostring(prop.ValueType) or "unknown",
+				category = prop.Category or "Other",
+				serialized = prop.Serialized,
+				owner = prop.Owner,
+			})
+		end
+	end
+
+	local methods = {}
+	local methodData = safeCall(function()
+		return ReflectionService:GetMethodsOfClass(className)
+	end)
+	if methodData then
+		for _, method in methodData do
+			local params = {}
+			if method.Parameters then
+				for _, param in method.Parameters do
+					table.insert(params, {
+						name = param.Name,
+						type = param.Type and tostring(param.Type) or "unknown",
+					})
+				end
+			end
+			table.insert(methods, {
+				name = method.Name,
+				parameters = params,
+				owner = method.Owner,
+			})
+		end
+	end
+
+	local events = {}
+	local eventData = safeCall(function()
+		return ReflectionService:GetEventsOfClass(className)
+	end)
+	if eventData then
+		for _, event in eventData do
+			local params = {}
+			if event.Parameters then
+				for _, param in event.Parameters do
+					table.insert(params, {
+						name = param.Name,
+						type = param.Type and tostring(param.Type) or "unknown",
+					})
+				end
+			end
+			table.insert(events, {
+				name = event.Name,
+				parameters = params,
+				owner = event.Owner,
+			})
+		end
+	end
+
+	local result = {
+		className = className,
+		properties = properties,
+		methods = methods,
+		events = events,
+	}
+
+	if classData then
+		result.superclass = classData.Superclass
+		result.creatable = classData.Creatable
+		result.serialized = classData.Serialized
+	end
+
+	if classErr and #properties == 0 then
+		result.error = "Could not reflect class: " .. tostring(classErr)
+	end
+
+	return result
+end
+
+function Reflection.getPropertyTypes(className)
+	local propData = safeCall(function()
+		return ReflectionService:GetPropertiesOfClass(className)
+	end)
+	if not propData then return {} end
+
+	local typeMap = {}
+	for _, prop in propData do
+		typeMap[prop.Name] = prop.ValueType and tostring(prop.ValueType) or "unknown"
+	end
+	return typeMap
+end
+
+function Reflection.listClasses()
+	local classes = safeCall(function()
+		return ReflectionService:GetClasses()
+	end)
+	if not classes then return {} end
+
+	local result = {}
+	for _, cls in classes do
+		table.insert(result, {
+			name = cls.Name,
+			superclass = cls.Superclass,
+			creatable = cls.Creatable,
+		})
+	end
+	return result
+end
+
+return Reflection