cluaupp 0.1.0

package/runtime/Cmdr/_impl/BuiltInCommands/Utility/jsonArrayEncode.luau

@@ -0,0 +1,18 @@
+const HttpService = game:GetService("HttpService")
+
+return {
+	Name = "json-array-encode",
+	Description = "Encodes a comma-separated list into a JSON array.",
+	Group = "DefaultUtil",
+	Args = {
+		{
+			Type = "string",
+			Name = "CSV",
+			Description = "The comma-separated list.",
+		},
+	},
+
+	ClientRun = function(_, text: string): string
+		return HttpService:JSONEncode(text:split(","))
+	end,
+}

package/runtime/Cmdr/_impl/BuiltInCommands/Utility/len.luau

@@ -0,0 +1,16 @@
+return {
+	Name = "len",
+	Description = "Returns the length of a comma-separated list.",
+	Group = "DefaultUtil",
+	Args = {
+		{
+			Type = "string",
+			Name = "CSV",
+			Description = "The comma-separated list.",
+		},
+	},
+
+	ClientRun = function(_, list: string): string
+		return if #list == 0 then "0" else tostring(#(list:split(",")))
+	end,
+}

package/runtime/Cmdr/_impl/BuiltInCommands/Utility/math.luau

@@ -0,0 +1,36 @@
+type MathOperation = { Name: string, Perform: (a: number, b: number) -> number }
+
+return {
+	Name = "math",
+	Description = "Perform a math operation on 2 values.",
+	Group = "DefaultUtil",
+	AutoExec = {
+		'alias "+|Perform an addition." math + $1{number|Number} $2{number|Number}',
+		'alias "-|Perform a subtraction." math - $1{number|Number} $2{number|Number}',
+		'alias "*|Perform a multiplication." math * $1{number|Number} $2{number|Number}',
+		'alias "/|Perform a division." math / $1{number|Number} $2{number|Number}',
+		'alias "**|Perform an exponentiation." math ** $1{number|Number} $2{number|Number}',
+		'alias "%|Perform a modulus." math % $1{number|Number} $2{number|Number}',
+	},
+	Args = {
+		{
+			Type = "mathOperator",
+			Name = "Operation",
+			Description = "A math operation",
+		},
+		{
+			Type = "number",
+			Name = "Value",
+			Description = "A number value",
+		},
+		{
+			Type = "number",
+			Name = "Value",
+			Description = "A number value",
+		},
+	},
+
+	ClientRun = function(_, operation: MathOperation, a: number, b: number): string
+		return tostring(operation.Perform(a, b))
+	end,
+}

package/runtime/Cmdr/_impl/BuiltInCommands/Utility/pick.luau

@@ -0,0 +1,21 @@
+return {
+	Name = "pick",
+	Description = "Picks a value out of a comma-separated list.",
+	Group = "DefaultUtil",
+	Args = {
+		{
+			Type = "positiveInteger",
+			Name = "Index to pick",
+			Description = "The index of the item you want to pick.",
+		},
+		{
+			Type = "string",
+			Name = "CSV",
+			Description = "The comma-separated list.",
+		},
+	},
+
+	ClientRun = function(_, index: number, list: string): string
+		return list:split(",")[index] or ""
+	end,
+}

package/runtime/Cmdr/_impl/BuiltInCommands/Utility/rand.luau

@@ -0,0 +1,27 @@
+const GENERATOR = Random.new()
+
+return {
+	Name = "rand",
+	Description = "Returns a random number between min and max.",
+	Group = "DefaultUtil",
+	Args = {
+		{
+			Type = "integer",
+			Name = "First number",
+			Description = "If second number is nil, random number is between 1 and this value. If second number is provided, number is between this number and the second number.",
+		},
+		{
+			Type = "integer",
+			Name = "Second number",
+			Description = "The upper bound.",
+			Optional = true,
+		},
+	},
+
+	ClientRun = function(_, firstNumber: number, secondNumber: number?): string
+		const min = if secondNumber then math.min(firstNumber, secondNumber) else math.min(1, firstNumber)
+		const max = if secondNumber then math.max(firstNumber, secondNumber) else math.max(1, firstNumber)
+
+		return tostring(GENERATOR:NextInteger(min, max))
+	end,
+}

package/runtime/Cmdr/_impl/BuiltInCommands/Utility/replace.luau

@@ -0,0 +1,32 @@
+return {
+	Name = "replace",
+	Aliases = { "gsub", "//" },
+	Description = "Replaces text A with text B.",
+	Group = "DefaultUtil",
+	AutoExec = {
+		'alias "map|Maps a CSV into another CSV." replace $1{string|CSV} ([^,]+) "$2{string|mapped value|Use %1 to insert the element.}"',
+		'alias "join|Joins a CSV with a specified delimiter." replace $1{string|CSV} , $2{string|Delimiter}',
+	},
+	Args = {
+		{
+			Type = "string",
+			Name = "Haystack",
+			Description = "The source string upon which to perform replacement.",
+		},
+		{
+			Type = "string",
+			Name = "Needle",
+			Description = "The string pattern search for.",
+		},
+		{
+			Type = "string",
+			Name = "Replacement",
+			Description = "The string to replace matches (%1 to insert matches).",
+			Default = "",
+		},
+	},
+
+	ClientRun = function(_, haystack: string, needle: string, replacement: string): string
+		return haystack:gsub(needle, replacement)
+	end,
+}

package/runtime/Cmdr/_impl/BuiltInCommands/Utility/resolve.luau

@@ -0,0 +1,32 @@
+return {
+	Name = "resolve",
+	Description = "Resolves Argument Value Operators into lists. E.g., resolve players * gives you a list of all players.",
+	Group = "DefaultUtil",
+	AutoExec = {
+		'alias "me|Displays your username." resolve players .',
+	},
+	Args = {
+		{
+			Type = "type",
+			Name = "Type",
+			Description = "The type for which to resolve.",
+		},
+		function(context: any)
+			if context:GetArgument(1):Validate() == false then
+				return
+			end
+
+			return {
+				Type = context:GetArgument(1):GetValue(),
+				Name = "Argument Value Operator",
+				Description = "The value operator to resolve. One of: * ** . ? ?N",
+				Optional = true,
+			}
+		end,
+	},
+
+	ClientRun = function(context: any): string
+		const arg = context:GetArgument(2)
+		return if arg then table.concat(arg.RawSegments, ",") else ""
+	end,
+}

package/runtime/Cmdr/_impl/BuiltInCommands/Utility/run.luau

@@ -0,0 +1,20 @@
+return {
+	Name = "run",
+	Aliases = { ">" },
+	AutoExec = {
+		'alias "discard|Run a command and discard the output." replace ${run $1} .* \\"\\"',
+	},
+	Description = "Runs a given command string (replacing embedded commands).",
+	Group = "DefaultUtil",
+	Args = {
+		{
+			Type = "string",
+			Name = "Command",
+			Description = "The command string to run.",
+		},
+	},
+
+	ClientRun = function(context: any, commandString: string): string
+		return context.Cmdr.Util.RunCommandString(context.Dispatcher, commandString)
+	end,
+}

package/runtime/Cmdr/_impl/BuiltInCommands/Utility/runLines.luau

@@ -0,0 +1,34 @@
+return {
+	Name = "run-lines",
+	Description = "Splits input by newlines and runs each line as its own command. This is used by the init-run command.",
+	Group = "DefaultUtil",
+	Args = {
+		{
+			Type = "string",
+			Name = "Script",
+			Description = "The script to parse.",
+			Default = "",
+		},
+	},
+
+	ClientRun = function(context: any, text: string): string
+		if #text == 0 then
+			return ""
+		end
+
+		const shouldPrintOutput = context.Dispatcher:Run("var", "INIT_PRINT_OUTPUT") ~= ""
+		const commands = text:gsub("\n+", "\n"):split("\n")
+		for _, command: string in ipairs(commands) do
+			if command:sub(1, 1) == "#" then
+				continue
+			end
+
+			const output = context.Dispatcher:EvaluateAndRun(command)
+			if shouldPrintOutput then
+				context:Reply(output)
+			end
+		end
+
+		return ""
+	end,
+}

package/runtime/Cmdr/_impl/BuiltInCommands/Utility/runif.luau

@@ -0,0 +1,95 @@
+type ConditionFn = (text: string, arg: string) -> string?
+
+const CONDITIONS: { [string]: ConditionFn } = {
+	startsWith = function(text, arg)
+		return text:sub(1, #arg) == arg and text:sub(#arg + 1)
+	end,
+
+	contains = function(text, arg)
+		return text:find(arg, 1, true) and text
+	end,
+
+	endsWith = function(text, arg)
+		return text:sub(-#arg) == arg and text:sub(1, -#arg - 1)
+	end,
+
+	pattern = function(text, arg)
+		return text:match(arg) and text
+	end,
+
+	equals = function(text, arg)
+		return text == arg and text
+	end,
+
+	notEquals = function(text, arg)
+		return text ~= arg and text
+	end,
+
+	greaterThan = function(text, arg)
+		return tonumber(arg) > tonumber(text) and text
+	end,
+
+	lessThan = function(text, arg)
+		return tonumber(arg) < tonumber(text) and text
+	end,
+
+	greaterThanOrEqual = function(text, arg)
+		return tonumber(arg) >= tonumber(text) and text
+	end,
+
+	lessThanOrEqual = function(text, arg)
+		return tonumber(arg) <= tonumber(text) and text
+	end,
+
+	length = function(text, arg)
+		return #text == tonumber(arg) and text
+	end,
+}
+
+const conditionNames = {}
+for name in pairs(CONDITIONS) do
+	conditionNames[#conditionNames + 1] = name
+end
+
+return {
+	Name = "runif",
+	Description = "Runs a given command string if a certain condition is met.",
+	Group = "DefaultUtil",
+	Args = {
+		function(context: any)
+			return {
+				Type = context.Cmdr.Util.MakeEnumType("ConditionFunction", conditionNames),
+				Name = "Condition",
+				Description = "The condition function.",
+			}
+		end,
+		{
+			Type = "string",
+			Name = "Argument",
+			Description = "The argument to the condition function.",
+		},
+		{
+			Type = "string",
+			Name = "Test against",
+			Description = "The text to test against.",
+		},
+		{
+			Type = "string",
+			Name = "Command",
+			Description = "The command string to run if requirements are met. If omitted, return value from condition function is used.",
+			Optional = true,
+		},
+	},
+
+	ClientRun = function(context: any, condition: string, arg: string, testAgainst: string, command: string?): string
+		const conditionFunc = CONDITIONS[condition]
+		const success, text = pcall(conditionFunc, testAgainst, arg)
+		if success and text then
+			return context.Dispatcher:EvaluateAndRun(
+				context.Cmdr.Util.RunEmbeddedCommands(context.Dispatcher, command or text)
+			)
+		end
+
+		return ""
+	end,
+}

package/runtime/Cmdr/_impl/BuiltInCommands/Utility/unbind.luau

@@ -0,0 +1,27 @@
+return {
+	Name = "unbind",
+	Description = "Unbinds an input previously bound with Bind.",
+	Group = "DefaultUtil",
+	Args = {
+		{
+			Type = "userInput @ player",
+			Name = "Input/Key",
+			Description = "The key or input type you'd like to unbind.",
+		},
+	},
+
+	ClientRun = function(context: any, bind: Enum.UserInputType | Enum.KeyCode | Player): string
+		const binds = context:GetStore("CMDR_Binds")
+
+		if binds[bind] then
+			if typeof(binds[bind]) == "RBXScriptConnection" then
+				binds[bind]:Disconnect()
+			end
+
+			binds[bind] = nil
+			return "Unbound command from input."
+		else
+			return "That input wasn't bound."
+		end
+	end,
+}

package/runtime/Cmdr/_impl/BuiltInCommands/Utility/var.luau

@@ -0,0 +1,29 @@
+const ReplicatedStorage = game:GetService("ReplicatedStorage")
+
+const BuiltInGuards = ReplicatedStorage.CmdrClient.Shared.BuiltInGuards
+const IsDataStoreAvailable = require(BuiltInGuards.IsDataStoreAvailable) :: (number?) -> (any) -> string?
+
+return {
+	Name = "var",
+	Description = "Gets a stored variable.",
+	Group = "DefaultUtil",
+	AutoExec = {
+		'alias "init-edit|Edit your initialization script." edit ${var init} \\\\\n && var= init ||',
+		'alias "init-run|Re-runs the initialization script manually." run-lines ${var init}',
+		"init-run",
+	},
+	Args = {
+		{
+			Type = "storedKey",
+			Name = "Key",
+			Description = "The key to get, retrieved from your user data store. Keys prefixed with . are not saved. Keys prefixed with $ are game-wide. Keys prefixed with $. are game-wide and non-saved.",
+		},
+	},
+	Guards = {
+		IsDataStoreAvailable(1),
+	},
+
+	ClientRun = function(context: any, key: any)
+		context:GetStore("vars_used")[key] = true
+	end,
+}

package/runtime/Cmdr/_impl/BuiltInCommands/Utility/varServer.luau

@@ -0,0 +1,37 @@
+return function(context: any, key: string): string
+	local gameWide = false
+	local saved = true
+
+	if key:sub(1, 1) == "$" then
+		key = key:sub(2)
+		gameWide = true
+	end
+
+	if key:sub(1, 1) == "." then
+		key = key:sub(2)
+		saved = false
+	end
+
+	const namespace = `var_{if gameWide then "global" else tostring(context.Executor.UserId)}`
+
+	if saved then
+		const dataStore = context.Cmdr.Util.GetDataStore()
+		const keyPath = `{namespace}_{key}`
+		const value = dataStore:GetAsync(keyPath) or ""
+
+		if type(value) == "table" then
+			return table.concat(value, ",") or ""
+		end
+
+		return tostring(value)
+	else
+		const store = context:GetStore(namespace)
+		const value = store[key] or ""
+
+		if type(value) == "table" then
+			return table.concat(value, ",") or ""
+		end
+
+		return tostring(value)
+	end
+end

package/runtime/Cmdr/_impl/BuiltInCommands/Utility/varSet.luau

@@ -0,0 +1,30 @@
+const ReplicatedStorage = game:GetService("ReplicatedStorage")
+
+const BuiltInGuards = ReplicatedStorage.CmdrClient.Shared.BuiltInGuards
+const IsDataStoreAvailable = require(BuiltInGuards.IsDataStoreAvailable) :: (number?) -> (any) -> string?
+
+return {
+	Name = "var=",
+	Description = "Sets a stored value.",
+	Group = "DefaultUtil",
+	Args = {
+		{
+			Type = "storedKey",
+			Name = "Key",
+			Description = "The key to set, saved in your user data store. Keys prefixed with . are not saved. Keys prefixed with $ are game-wide. Keys prefixed with $. are game-wide and non-saved.",
+		},
+		{
+			Type = "string",
+			Name = "Value",
+			Description = "Value or values to set.",
+			Default = "",
+		},
+	},
+	Guards = {
+		IsDataStoreAvailable(1),
+	},
+
+	ClientRun = function(context: any, key: string)
+		context:GetStore("vars_used")[key] = true
+	end,
+}

package/runtime/Cmdr/_impl/BuiltInCommands/Utility/varSetServer.luau

@@ -0,0 +1,29 @@
+return function(context: any, key: string, value: string): string
+	local gameWide = false
+	local saved = true
+
+	if key:sub(1, 1) == "$" then
+		key = key:sub(2)
+		gameWide = true
+	end
+
+	if key:sub(1, 1) == "." then
+		key = key:sub(2)
+		saved = false
+	end
+
+	const namespace = `var_{if gameWide then "global" else tostring(context.Executor.UserId)}`
+
+	if saved then
+		const dataStore = context.Cmdr.Util.GetDataStore()
+		const keyPath = `{namespace}_{key}`
+		dataStore:SetAsync(keyPath, value)
+
+		return value
+	else
+		const store = context:GetStore(namespace)
+		store[key] = value
+
+		return value
+	end
+end

package/runtime/Cmdr/_impl/BuiltInCommands/help.luau

@@ -0,0 +1,96 @@
+const COMMAND_COLOR = Color3.fromRGB(230, 126, 34)
+const TEXT_COLOR = Color3.fromRGB(230, 230, 230)
+
+const ARGUMENT_SHORTHANDS = [[
+Argument Shorthands
+-------------------
+.   Me/Self
+*   All/Everyone
+**  Others
+?   Random
+?N  List of N random values
+]]
+
+const TIPS = [[
+Tips
+----
+• Use the Tab key to autocomplete commands and suggestions
+• Easily select and copy command output
+]]
+
+return {
+	Name = "help",
+	Aliases = { "cmds", "commands" },
+	Description = "Displays a list of all commands, or inspects one command.",
+	Group = "Help",
+
+	Args = {
+		{
+			Type = "command",
+			Name = "Command",
+			Description = "The command to view information on.",
+			Optional = true,
+		},
+	},
+
+	ClientRun = function(context: any, commandName: string?): string
+		const registry = context.Cmdr.Registry
+		if commandName then
+			const command = registry:GetCommand(commandName)
+			context:Reply(`Command: {command.Name}`, COMMAND_COLOR)
+
+			if command.Aliases and #command.Aliases > 0 then
+				context:Reply(`Aliases: {table.concat(command.Aliases, ", ")}`, TEXT_COLOR)
+			end
+
+			if command.Description then
+				context:Reply(`Description: {command.Description}`, TEXT_COLOR)
+			end
+
+			if command.Group then
+				context:Reply(`Group: {command.Group}`, TEXT_COLOR)
+			end
+
+			if command.Args then
+				for index, argument in ipairs(command.Args) do
+					if type(argument) == "table" then
+						const optional = if argument.Optional then "?" else ""
+
+						context:Reply(`#{index} {argument.Name}{optional}: {argument.Type} - {argument.Description}`)
+					else
+						context:Reply(`#{index} Unknown (inline argument)`)
+					end
+				end
+			end
+		else
+			context:Reply(ARGUMENT_SHORTHANDS)
+			context:Reply(TIPS)
+
+			const commands = registry:GetCommands()
+			table.sort(commands, function(a, b)
+				if a.Group and b.Group then
+					return a.Group < b.Group
+				end
+
+				return a.Group ~= nil
+			end)
+
+			local lastGroup
+			for _, command in ipairs(commands) do
+				if command._isHidden then
+					continue
+				end
+
+				const group = command.Group or "No Group"
+				if lastGroup ~= group then
+					context:Reply(`\n{group}\n{("-"):rep(#group)}`)
+					lastGroup = group
+				end
+
+				context:Reply(if command.Description then `{command.Name} - {command.Description}` else command.Name)
+			end
+		end
+
+		return ""
+	end,
+}