@el4cteo/rbx-studio-mcp 0.3.0 → 0.3.5

package/plugin/src/Paths.luau

@@ -95,25 +95,106 @@ local function siblingIndex(instance: Instance, memo: NameIndex?): number?
 	return nil
 end
 
+--[[
+	Names a parent's children for an error message, collapsing repeats.
+
+	Same-named siblings are ordinary in Roblox, and listing them one by one spent
+	the whole budget saying "Part, Part, Part" 25 times -- which tells a reader
+	nothing and hides the names that would have helped. Repeats are counted
+	instead, and the count is exactly what says an index is needed.
+]]
 local function childNames(parent: Instance, limit: number): string
-	local names: { string } = {}
+	local order: { string } = {}
+	local counts: { [string]: number } = {}
 	for _, child in parent:GetChildren() do
-		table.insert(names, child.Name)
-		if #names >= limit then
-			table.insert(names, "...")
-			break
+		if counts[child.Name] == nil then
+			counts[child.Name] = 0
+			table.insert(order, child.Name)
 		end
+		counts[child.Name] += 1
 	end
-	if #names == 0 then
+
+	if #order == 0 then
 		return "(no children)"
 	end
+
+	local names: { string } = {}
+	for _, name in order do
+		if #names >= limit then
+			table.insert(names, string.format("... %d more", #order - limit))
+			break
+		end
+		local count = counts[name]
+		table.insert(names, if count > 1 then string.format("%s (x%d)", name, count) else name)
+	end
 	return table.concat(names, ", ")
 end
 
+--[[
+	Finds one child by a single segment, honouring "Name[2]" and, at the root,
+	fetching services by class name -- they are not always present as children
+	until first accessed.
+
+	The second return is a diagnostic for the one miss a caller cannot work out
+	from the sibling list: an index past the end of a name that does exist.
+]]
+local function childBySegment(
+	parent: Instance,
+	segment: string,
+	atRoot: boolean
+): (Instance?, string?)
+	local name, ordinal = parseSegment(segment)
+
+	if ordinal then
+		local list = childrenByName(parent, nil)[name]
+		if list == nil then
+			return nil, nil
+		end
+		local child = list[ordinal]
+		if child then
+			return child, nil
+		end
+		return nil,
+			string.format(
+				'"%s" has %d child%s named "%s", so [%d] is past the end. Indexes are '
+					.. "1-based and shift when siblings are added or removed -- read a "
+					.. "fresh path from `find` or `tree`.",
+				parent:GetFullName(),
+				#list,
+				if #list == 1 then "" else "ren",
+				name,
+				ordinal
+			)
+	end
+
+	if atRoot then
+		local ok, service = pcall(function()
+			return game:GetService(name :: any)
+		end)
+		if ok and service then
+			return service, nil
+		end
+	end
+	return parent:FindFirstChild(name), nil
+end
+
 --[[
 	Resolves a path to an Instance, or raises a NOT_FOUND with the failing
 	segment and its siblings. `FindFirstChild` is used rather than indexing so a
 	missing child never throws a bare Luau error.
+
+	Instance names may contain dots -- "Dr. Simon" is an ordinary name, and so is
+	"v1.2 backup" -- while the separator is a dot too, so such a name arrives
+	here already split into pieces. Each step therefore tries consuming one
+	segment first and rejoins further segments only if that leads nowhere, which
+	means the search has to BACK TRACK: with both "Dr" and "Dr. Who" present,
+	"Workspace.Dr. Who.Head" matches "Dr", fails to find " Who" under it, and
+	must return to try "Dr. Who". A first pass without that backtracking left the
+	tools emitting `Workspace.Dr. Who` as a path and then refusing to read it
+	back, which is worse than either behaviour on its own.
+
+	Shortest-first keeps the old precedence: where a short name resolves the
+	whole remaining path, it still wins over a longer join.
 ]]
 function Paths.resolve(path: string): Instance
 	if typeof(path) ~= "string" or path == "" then
@@ -130,78 +211,66 @@ function Paths.resolve(path: string): Instance
 		return game
 	end
 
-	local current: Instance = game
-	local index = 1
-	while index <= #segments do
-		local segment = segments[index]
-		local name, ordinal = parseSegment(segment)
-		local nextInstance: Instance? = nil
-		local consumed = 1
-
-		if ordinal then
-			-- Explicit disambiguation: take the nth child with this exact name.
-			local list = childrenByName(current, nil)[name]
-			nextInstance = if list then list[ordinal] else nil
-		elseif index == 1 then
-			-- Services must be fetched by class name, and are not always
-			-- present as children until first accessed.
-			local ok, service = pcall(function()
-				return game:GetService(name :: any)
-			end)
-			nextInstance = if ok then service else current:FindFirstChild(name)
-		else
-			nextInstance = current:FindFirstChild(name)
+	-- The deepest point any branch of the search reached, so a failure still
+	-- reports the segment that actually broke rather than the first one tried.
+	local deepest = 0
+	local deepestParent: Instance = game
+	local deepestNote: string? = nil
+	-- The segment text the note is about: with a rejoined name it is not
+	-- `segments[failedAt]`, and reporting that instead named "Mr" for a path
+	-- that asked for "Mr. X[3]".
+	local deepestSegment: string? = nil
+
+	local function walk(current: Instance, index: number): Instance?
+		if index > #segments then
+			return current
+		end
+		if index - 1 > deepest then
+			deepest = index - 1
+			deepestParent = current
+			deepestNote = nil
+			deepestSegment = nil
 		end
 
-		--[[
-			Instance names may contain dots -- "Dr. Simon" is an ordinary name --
-			and the separator is a dot too, so such a name arrives here already
-			split into pieces that match nothing. Rejoin greedily, longest first,
-			so "Workspace.Dr. Simon.Head" finds the child actually called
-			"Dr. Simon" rather than failing on a segment named "Dr".
-
-			Only attempted after the plain lookup misses, so a place where both
-			"Dr" and "Dr. Simon" exist still resolves the short name to itself.
-		]]
-		if not nextInstance and index < #segments then
-			for last = #segments, index + 1, -1 do
-				local joined = table.concat(segments, ".", index, last)
-				local joinedName, joinedOrdinal = parseSegment(joined)
-				local found: Instance? = nil
-				if joinedOrdinal then
-					local list = childrenByName(current, nil)[joinedName]
-					found = if list then list[joinedOrdinal] else nil
-				else
-					found = current:FindFirstChild(joinedName)
-				end
+		for last = index, #segments do
+			local joined = table.concat(segments, ".", index, last)
+			local child, note = childBySegment(current, joined, index == 1)
+			if note and index - 1 == deepest then
+				deepestNote = note
+				deepestSegment = joined
+			end
+			if child then
+				local found = walk(child, last + 1)
 				if found then
-					nextInstance = found
-					consumed = last - index + 1
-					break
+					return found
 				end
 			end
 		end
+		return nil
+	end
 
-		if not nextInstance then
-			local partial = table.concat(segments, ".", 1, index)
-			-- `fail` never returns; returning its result keeps that visible to
-			-- the type checker so `current` stays non-optional below.
-			return Dispatch.fail(
-				"NOT_FOUND",
-				string.format('No instance at "%s".', partial),
-				string.format(
-					'"%s" has no child named "%s". It does have: %s',
-					current:GetFullName(),
-					segment,
-					childNames(current, 25)
-				)
-			)
-		end
-		current = nextInstance
-		index += consumed
+	local resolved = walk(game, 1)
+	if resolved then
+		return resolved
 	end
 
-	return current
+	local failedAt = deepest + 1
+	local reached = if deepest > 0 then table.concat(segments, ".", 1, deepest) .. "." else ""
+	local named = if deepestSegment
+		then reached .. deepestSegment
+		else table.concat(segments, ".", 1, failedAt)
+	return Dispatch.fail(
+		"NOT_FOUND",
+		string.format('No instance at "%s".', named),
+		if deepestNote
+			then deepestNote
+			else string.format(
+				'"%s" has no child named "%s". It does have: %s',
+				deepestParent:GetFullName(),
+				segments[failedAt],
+				childNames(deepestParent, 25)
+			)
+	)
 end
 
 --[[

package/plugin/src/Serialize.luau

@@ -151,6 +151,31 @@ function Serialize.readProperty(instance: Instance, name: string): (boolean, any
 	return true, Serialize.value(value)
 end
 
+--[[
+	Pulls the numbers out of a composite value written as text.
+
+	This used to be a single `-?%d+%.?%d*` scan, which is not the grammar Luau
+	numbers actually have: "1e3, 0, .5" came back as 1, 3 and 0, so a Position
+	written in scientific notation was silently set to a different point in the
+	world and reported as applied. Splitting on the separators and handing each
+	token to `tonumber` means this agrees with the scalar path, which always
+	used `tonumber` -- the two disagreeing about what counts as a number was the
+	whole bug.
+
+	Non-numeric tokens are dropped, so "Vector3.new(1, 2, 3)" and "{1, 2, 3}"
+	still read as three numbers.
+]]
+local function scanTokens(text: string): { number }
+	local numbers: { number } = {}
+	for token in string.gmatch(text, "[^,%s%(%)%[%]{}<>]+") do
+		local value = tonumber(token)
+		if value then
+			table.insert(numbers, value)
+		end
+	end
+	return numbers
+end
+
 --[[
 	Parses a serialized string back into a Roblox value, given the target type
 	from the API dump. Returns ok=false with a reason the agent can act on
@@ -176,7 +201,22 @@ function Serialize.parse(text: any, valueType: string): (boolean, any, string?)
 		if kind == "boolean" then
 			return true, text, nil
 		end
-		return true, text == "true", nil
+		if kind == "number" then
+			return true, text ~= 0, nil
+		end
+		-- This used to be `text == "true"`, which quietly turned "True", "TRUE"
+		-- and "1" into false and reported the write as applied. A bool that is
+		-- silently the opposite of what was asked is the worst failure this
+		-- module can produce, so near misses are accepted and anything else is
+		-- refused rather than guessed at.
+		local lowered = string.lower(tostring(text))
+		if lowered == "true" or lowered == "1" or lowered == "yes" then
+			return true, true, nil
+		end
+		if lowered == "false" or lowered == "0" or lowered == "no" then
+			return true, false, nil
+		end
+		return false, nil, string.format('expected true or false, got "%s"', tostring(text))
 	end
 	if NUMERIC_TYPES[valueType] then
 		local parsed = tonumber(text)
@@ -188,8 +228,8 @@ function Serialize.parse(text: any, valueType: string): (boolean, any, string?)
 
 	local numbers: { number } = {}
 	if kind == "string" then
-		for match in string.gmatch(text, "-?%d+%.?%d*") do
-			table.insert(numbers, tonumber(match) :: number)
+		for _, token in scanTokens(text) do
+			table.insert(numbers, token)
 		end
 	elseif kind == "table" then
 		for _, item in text :: { any } do