dominus-cli 0.1.0

package/plugin/src/TestRunner.lua

@@ -0,0 +1,141 @@
+--[[
+	TestRunner: interface with StudioTestService for automated testing
+	https://create.roblox.com/docs/reference/engine/classes/StudioTestService
+
+	StudioTestService allows plugins to:
+	- ExecuteRunModeAsync(args) → start Run mode, yield until EndTest
+	- ExecutePlayModeAsync(args) → start Play/Solo mode, yield until EndTest
+	- GetTestArgs() → retrieve args from inside the running session
+	- EndTest(value) → end the session and return a value
+]]
+
+local TestRunner = {}
+
+local StudioTestService = game:GetService("StudioTestService")
+
+function TestRunner.executeRunMode(args)
+	local startTime = os.clock()
+	local ok, result = pcall(function()
+		return StudioTestService:ExecuteRunModeAsync(args)
+	end)
+	local duration = os.clock() - startTime
+
+	if not ok then
+		return {
+			success = false,
+			error = tostring(result),
+			duration = duration,
+		}
+	end
+
+	return {
+		success = true,
+		result = result,
+		duration = duration,
+	}
+end
+
+function TestRunner.executePlayMode(args)
+	local startTime = os.clock()
+	local ok, result = pcall(function()
+		return StudioTestService:ExecutePlayModeAsync(args)
+	end)
+	local duration = os.clock() - startTime
+
+	if not ok then
+		return {
+			success = false,
+			error = tostring(result),
+			duration = duration,
+		}
+	end
+
+	return {
+		success = true,
+		result = result,
+		duration = duration,
+	}
+end
+
+function TestRunner.endTest(value)
+	local ok, err = pcall(function()
+		StudioTestService:EndTest(value)
+	end)
+
+	if not ok then
+		return { success = false, error = tostring(err) }
+	end
+
+	return { success = true }
+end
+
+function TestRunner.run(testName)
+	local results = {}
+
+	local ok, err = pcall(function()
+		local TestService = game:GetService("TestService")
+
+		if testName then
+			local testScript = nil
+			for _, desc in game:GetDescendants() do
+				if desc:IsA("ModuleScript") and desc.Name == testName then
+					testScript = desc
+					break
+				end
+			end
+
+			if not testScript then
+				table.insert(results, {
+					name = testName,
+					passed = false,
+					duration = 0,
+					error = "Test not found: " .. testName,
+				})
+				return
+			end
+
+			local startTime = os.clock()
+			local testOk, testErr = pcall(function()
+				require(testScript)
+			end)
+			local duration = os.clock() - startTime
+
+			table.insert(results, {
+				name = testName,
+				passed = testOk,
+				duration = duration,
+				error = not testOk and tostring(testErr) or nil,
+			})
+		else
+			for _, desc in game:GetDescendants() do
+				if desc:IsA("ModuleScript") then
+					local name = desc.Name
+					if string.match(name, "%.test$") or string.match(name, "%.spec$")
+						or string.match(name, "Test$") or string.match(name, "Spec$") then
+
+						local startTime = os.clock()
+						local testOk, testErr = pcall(function()
+							require(desc)
+						end)
+						local duration = os.clock() - startTime
+
+						table.insert(results, {
+							name = name,
+							passed = testOk,
+							duration = duration,
+							error = not testOk and tostring(testErr) or nil,
+						})
+					end
+				end
+			end
+		end
+	end)
+
+	if not ok then
+		return { results = {{ name = "TestRunner", passed = false, duration = 0, error = tostring(err) }} }
+	end
+
+	return { results = results }
+end
+
+return TestRunner

package/plugin/src/UIBuilder.lua

@@ -0,0 +1,247 @@
+--[[
+	UIBuilder: create entire UI trees from a declarative JSON spec in one call.
+	Handles all type coercion natively in Luau — no round trips needed.
+]]
+
+local Explorer = require(script.Parent.Explorer)
+
+local UIBuilder = {}
+
+local function resolveColor(value)
+	if type(value) == "string" then
+		if value:sub(1, 1) == "#" then
+			return Color3.fromHex(value)
+		end
+		local r, g, b = value:match("rgb%s*%((%d+)%D+(%d+)%D+(%d+)%)")
+		if r then return Color3.fromRGB(tonumber(r), tonumber(g), tonumber(b)) end
+		local ok, bc = pcall(BrickColor.new, value)
+		if ok then return bc.Color end
+	end
+	if type(value) == "table" then
+		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
+		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
+	end
+	return Color3.new(1, 1, 1)
+end
+
+local function resolveUDim2(value)
+	if type(value) == "table" then
+		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
+		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
+		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
+	end
+	if type(value) == "string" then
+		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
+	return UDim2.new(0, 0, 0, 0)
+end
+
+local function resolveUDim(value)
+	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(0, value)
+	end
+	return UDim.new(0, 0)
+end
+
+local function resolveVector2(value)
+	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
+	return Vector2.new(0, 0)
+end
+
+local function resolveEnum(instance, key, value)
+	if type(value) ~= "string" then return value end
+	local curOk, curVal = pcall(function() return instance[key] end)
+	if curOk and typeof(curVal) == "EnumItem" then
+		local enumType = tostring(curVal.EnumType)
+		local ok, enumVal = pcall(function() return Enum[enumType][value] end)
+		if ok then return enumVal end
+	end
+	return value
+end
+
+local function resolveFont(value)
+	if type(value) == "string" then
+		local ok, font = pcall(function() return Enum.Font[value] end)
+		if ok then return font end
+	end
+	return value
+end
+
+local UDIM2_PROPS = {
+	Size = true, Position = true, AnchorPoint_UDim2 = true,
+}
+
+local COLOR_PROPS = {
+	BackgroundColor3 = true, BorderColor3 = true, TextColor3 = true,
+	ImageColor3 = true, PlaceholderColor3 = true, TextStrokeColor3 = true,
+	ScrollBarImageColor3 = true, Color = true,
+}
+
+local VECTOR2_PROPS = {
+	AnchorPoint = true, CanvasSize_v2 = true,
+}
+
+local function applyProperty(instance, key, value)
+	-- Special handling by property name
+	if key == "Size" or key == "Position" then
+		if instance:IsA("GuiObject") or instance:IsA("ScreenGui") then
+			instance[key] = resolveUDim2(value)
+			return
+		end
+	end
+
+	if key == "AnchorPoint" then
+		if instance:IsA("GuiObject") then
+			instance[key] = resolveVector2(value)
+			return
+		end
+	end
+
+	if key == "CanvasSize" and instance:IsA("ScrollingFrame") then
+		instance[key] = resolveUDim2(value)
+		return
+	end
+
+	if key == "CornerRadius" then
+		instance[key] = resolveUDim(value)
+		return
+	end
+
+	if COLOR_PROPS[key] then
+		instance[key] = resolveColor(value)
+		return
+	end
+
+	if key == "Font" and instance:IsA("TextLabel") or instance:IsA("TextButton") or instance:IsA("TextBox") then
+		instance[key] = resolveFont(value)
+		return
+	end
+
+	if key == "FontFace" then
+		if type(value) == "table" then
+			local family = value.Family or "rbxasset://fonts/families/SourceSansPro.json"
+			local weight = Enum.FontWeight.Regular
+			local style = Enum.FontStyle.Normal
+			pcall(function() weight = Enum.FontWeight[value.Weight or "Regular"] end)
+			pcall(function() style = Enum.FontStyle[value.Style or "Normal"] end)
+			instance.FontFace = Font.new(family, weight, style)
+		end
+		return
+	end
+
+	-- Enum properties (string values)
+	if type(value) == "string" then
+		local resolved = resolveEnum(instance, key, value)
+		local ok, err = pcall(function() instance[key] = resolved end)
+		if not ok then
+			-- Maybe it's a direct value
+			pcall(function() instance[key] = value end)
+		end
+		return
+	end
+
+	-- Direct assignment for numbers, booleans, etc.
+	pcall(function() instance[key] = value end)
+end
+
+local function buildNode(spec, parent)
+	local className = spec.ClassName or spec.className or "Frame"
+	local name = spec.Name or spec.name or className
+
+	local instance = Instance.new(className)
+	instance.Name = name
+
+	-- Apply all properties
+	for key, value in spec do
+		if key ~= "ClassName" and key ~= "className" and key ~= "Name" and key ~= "name" and key ~= "Children" and key ~= "children" then
+			applyProperty(instance, key, value)
+		end
+	end
+
+	-- Set parent after properties to avoid unnecessary layout computations
+	instance.Parent = parent
+
+	-- Build children recursively
+	local children = spec.Children or spec.children
+	if children then
+		for _, childSpec in children do
+			buildNode(childSpec, instance)
+		end
+	end
+
+	return instance
+end
+
+function UIBuilder.build(spec)
+	local parentPath = spec.parent or "StarterGui"
+	local parent = Explorer.resolveInstance(parentPath)
+	if not parent then
+		-- Try as a service
+		local ok
+		ok, parent = pcall(function() return game:GetService(parentPath) end)
+		if not ok then
+			return { success = false, error = "Parent not found: " .. parentPath }
+		end
+	end
+
+	-- Clean up existing instance with same name
+	local existingName = spec.tree and (spec.tree.Name or spec.tree.name) or nil
+	if existingName then
+		local existing = parent:FindFirstChild(existingName)
+		if existing then
+			existing:Destroy()
+		end
+	end
+
+	local tree = spec.tree
+	if not tree then
+		return { success = false, error = "No 'tree' provided in spec" }
+	end
+
+	local ok, result = pcall(function()
+		return buildNode(tree, parent)
+	end)
+
+	if not ok then
+		return { success = false, error = "Build failed: " .. tostring(result) }
+	end
+
+	local path = Explorer.getPath(result)
+	local count = 0
+	local function countDescendants(inst)
+		count = count + 1
+		for _, child in inst:GetChildren() do
+			countDescendants(child)
+		end
+	end
+	countDescendants(result)
+
+	return { success = true, path = path, instanceCount = count }
+end
+
+return UIBuilder

package/plugin/src/Watcher.lua

@@ -0,0 +1,85 @@
+--[[
+	Watcher: monitors LogService output and forwards to CLI
+]]
+
+local LogService = game:GetService("LogService")
+
+local Watcher = {}
+
+local outputBuffer = {}
+local MAX_BUFFER = 500
+local connection = nil
+local outputCallback = nil
+
+local function classifyLevel(messageType)
+	if messageType == Enum.MessageType.MessageOutput then
+		return "info"
+	elseif messageType == Enum.MessageType.MessageWarning then
+		return "warn"
+	elseif messageType == Enum.MessageType.MessageError then
+		return "error"
+	end
+	return "info"
+end
+
+function Watcher.start(callback)
+	outputCallback = callback
+
+	if connection then
+		connection:Disconnect()
+	end
+
+	connection = LogService.MessageOut:Connect(function(message, messageType)
+		-- Skip Dominus's own messages
+		if string.find(message, "[Dominus]", 1, true) then
+			return
+		end
+
+		local entry = {
+			message = message,
+			level = classifyLevel(messageType),
+			timestamp = os.clock(),
+		}
+
+		-- Buffer for get_output requests
+		table.insert(outputBuffer, entry)
+		if #outputBuffer > MAX_BUFFER then
+			table.remove(outputBuffer, 1)
+		end
+
+		-- Forward to CLI
+		if outputCallback then
+			outputCallback(entry)
+		end
+	end)
+end
+
+function Watcher.stop()
+	if connection then
+		connection:Disconnect()
+		connection = nil
+	end
+	outputCallback = nil
+end
+
+function Watcher.getRecentOutput(limit, levelFilter)
+	limit = limit or 50
+	local result = {}
+
+	for i = math.max(1, #outputBuffer - limit + 1), #outputBuffer do
+		local entry = outputBuffer[i]
+		if entry then
+			if not levelFilter or entry.level == levelFilter then
+				table.insert(result, entry)
+			end
+		end
+	end
+
+	return { entries = result }
+end
+
+function Watcher.clearBuffer()
+	outputBuffer = {}
+end
+
+return Watcher

package/plugin/src/WsClient.lua

@@ -0,0 +1,81 @@
+--[[
+	WebSocket client wrapper using HttpService:CreateWebStreamClient
+	Uses the new WebSocket API available in Studio plugins (Oct 2025+)
+]]
+
+local HttpService = game:GetService("HttpService")
+
+local WsClient = {}
+WsClient.__index = WsClient
+
+local currentConnection = nil
+local messageCallback = nil
+local closeCallback = nil
+local errorCallback = nil
+
+function WsClient.connect(url, callbacks)
+	local ok, wsOrErr = pcall(function()
+		return HttpService:CreateWebStreamClient(Enum.WebStreamClientType.WebSocket, {
+			Url = url,
+		})
+	end)
+
+	if not ok then
+		warn("[Dominus WS] Failed to create WebSocket:", wsOrErr)
+		if callbacks.onError then
+			callbacks.onError(tostring(wsOrErr))
+		end
+		return false
+	end
+
+	local wsClient = wsOrErr
+	currentConnection = wsClient
+
+	-- Handle incoming messages
+	wsClient.MessageReceived:Connect(function(message)
+		if callbacks.onMessage then
+			callbacks.onMessage(message)
+		end
+	end)
+
+	-- Handle disconnection
+	wsClient.Closed:Connect(function()
+		currentConnection = nil
+		if callbacks.onClose then
+			callbacks.onClose()
+		end
+	end)
+
+	-- Notify connected
+	if callbacks.onOpen then
+		callbacks.onOpen()
+	end
+
+	return true
+end
+
+function WsClient.send(message)
+	if currentConnection then
+		local ok, err = pcall(function()
+			currentConnection:Send(message)
+		end)
+		if not ok then
+			warn("[Dominus WS] Send error:", err)
+		end
+	end
+end
+
+function WsClient.disconnect()
+	if currentConnection then
+		pcall(function()
+			currentConnection:Close()
+		end)
+		currentConnection = nil
+	end
+end
+
+function WsClient.isConnected()
+	return currentConnection ~= nil
+end
+
+return WsClient