A little more color

Author: samuel-williams-shopify

data/toolbox/command.py

@@ -157,75 +157,92 @@ def parse(self, argument_string):
 		# Return new Arguments with converted options
 		return Arguments(arguments.expressions, arguments.flags, converted_options)
 
-	def help_text(self, command_name):
+	def help_text(self, command_name, terminal):
 		"""Generate help text from usage specification.
 		
 		Args:
-			command_name: Name of the command (e.g., "rb-object-print")
+			command_name: Name of the command (e.g., "rb-print")
+			terminal: Terminal for colored output
 		
 		Returns:
 			Formatted help string with usage, parameters, options, and flags
 		"""
-		lines = [self.summary, ""]
+		import format as fmt
+		
+		# Summary with color
+		lines = [terminal.print(fmt.bold, self.summary, fmt.reset), ""]
 
 		# Build usage line
-		usage_parts = [command_name]
+		usage_parts = [terminal.print(fmt.bold, command_name, fmt.reset)]
+		
 		for param_name, _ in self.parameters:
-			usage_parts.append(f"<{param_name}>")
+			usage_parts.append(terminal.print(fmt.placeholder, f"<{param_name}>", fmt.reset))
 
 		# Add option placeholders
 		for option_name in self.options.keys():
-			usage_parts.append(f"[--{option_name} N]")
+			opt_placeholder = f"[--{option_name} N]"
+			usage_parts.append(terminal.print(fmt.placeholder, opt_placeholder, fmt.reset))
 
 		# Add flag placeholders
 		for flag_name, _ in self.flags:
-			usage_parts.append(f"[--{flag_name}]")
+			flag_placeholder = f"[--{flag_name}]"
+			usage_parts.append(terminal.print(fmt.placeholder, flag_placeholder, fmt.reset))
 
 		lines.append(f"Usage: {' '.join(usage_parts)}")
 		lines.append("")
 
 		# Parameter descriptions
 		if self.parameters:
-			lines.append("Parameters:")
+			lines.append(terminal.print(fmt.title, "Parameters:", fmt.reset))
+			
 			for param_name, param_desc in self.parameters:
+				param_str = terminal.print(fmt.symbol, param_name, fmt.reset)
 				if param_desc:
-					lines.append(f"  {param_name:<15} {param_desc}")
+					lines.append(f"  {param_str:<15} {param_desc}")
 				else:
-					lines.append(f"  {param_name}")
+					lines.append(f"  {param_str}")
 			lines.append("")
 
 		# Option descriptions
 		if self.options:
-			lines.append("Options:")
+			lines.append(terminal.print(fmt.title, "Options:", fmt.reset))
+			
 			for option_name, opt_spec in self.options.items():
 				opt_type, opt_default = opt_spec[0], opt_spec[1]
 				opt_desc = opt_spec[2] if len(opt_spec) > 2 else None
 
 				type_str = opt_type.__name__ if hasattr(opt_type, '__name__') else str(opt_type)
 				default_str = f" (default: {opt_default})" if opt_default is not None else ""
 
+				opt_str = terminal.print(fmt.symbol, f"--{option_name}", fmt.reset)
+				type_part = terminal.print(fmt.placeholder, f" <{type_str}>", fmt.reset)
+				
 				if opt_desc:
-					lines.append(f"  --{option_name} <{type_str}>{default_str}")
+					lines.append(f"  {opt_str}{type_part}{default_str}")
 					lines.append(f"      {opt_desc}")
 				else:
-					lines.append(f"  --{option_name} <{type_str}>{default_str}")
+					lines.append(f"  {opt_str}{type_part}{default_str}")
 			lines.append("")
 
 		# Flag descriptions
 		if self.flags:
-			lines.append("Flags:")
+			lines.append(terminal.print(fmt.title, "Flags:", fmt.reset))
+			
 			for flag_name, flag_desc in self.flags:
+				flag_str = terminal.print(fmt.symbol, f"--{flag_name}", fmt.reset)
 				if flag_desc:
-					lines.append(f"  --{flag_name:<15} {flag_desc}")
+					lines.append(f"  {flag_str:<15} {flag_desc}")
 				else:
-					lines.append(f"  --{flag_name}")
+					lines.append(f"  {flag_str}")
 			lines.append("")
 
 		# Examples section
 		if self.examples:
-			lines.append("Examples:")
+			lines.append(terminal.print(fmt.title, "Examples:", fmt.reset))
+			
 			for example_cmd, example_desc in self.examples:
-				lines.append(f"  {example_cmd}")
+				cmd_str = terminal.print(fmt.example, f"  {example_cmd}", fmt.reset)
+				lines.append(cmd_str)
 				if example_desc:
 					lines.append(f"      {example_desc}")
 			lines.append("")

data/toolbox/context.py

@@ -385,7 +385,7 @@ def invoke(self, arg, from_tty):
             flags_set = {'debug'} if debug else set()
             args_for_printer = command.Arguments([storage_val], flags_set, {'depth': depth})
 
-            printer.invoke(args_for_printer, terminal, from_tty)
+            printer.invoke(args_for_printer, terminal)
 
         except Exception as e:
             print(f"Error: {e}")

data/toolbox/debugger/gdb_backend.py

@@ -3,6 +3,7 @@
 """
 
 import gdb
+import format
 
 # Command categories
 COMMAND_DATA = gdb.COMMAND_DATA
@@ -341,71 +342,6 @@ def invoke(self, arg, from_tty):
 		raise NotImplementedError("Subclasses must implement invoke()")
 
 
-def register(command_name, command_class, usage=None, category=COMMAND_USER):
-	"""Register a command with GDB using declarative interface.
-	
-	Creates a wrapper that handles argument parsing, validation, and delegation.
-	
-	Args:
-		command_name: Name of the command (e.g., "rb-object-print")
-		command_class: Class to instantiate (must have invoke(arguments, from_tty) method)
-		usage: Optional command.Usage specification for validation and help
-		category: Command category (COMMAND_USER or COMMAND_DATA)
-	
-	Returns:
-		The registered command wrapper instance
-	
-	Example:
-		class RubyObjectPrinter:
-			def invoke(self, arguments, from_tty):
-				value_expr = arguments.expressions[0]
-				depth = arguments.get_option('depth', 1)
-				# ... print logic
-		
-		debugger.register("rb-object-print", RubyObjectPrinter, 
-		                  usage=RubyObjectPrinter.USAGE)
-	"""
-	class RegisteredCommand(Command):
-		def __init__(self):
-			super().__init__(command_name, category)
-			self.command_instance = None
-			self.usage_spec = usage
-		
-		def invoke(self, arg, from_tty):
-			try:
-				# Parse and validate arguments
-				if self.usage_spec:
-					arguments = self.usage_spec.parse(arg if arg else "")
-				else:
-					# Fallback: use raw parsing
-					import command as cmd_module
-					arguments = cmd_module.parse_arguments(arg if arg else "")
-				
-				# Create terminal for formatting
-				import format
-				terminal = format.create_terminal(from_tty)
-				
-				# Lazy instantiate command class
-				if self.command_instance is None:
-					self.command_instance = command_class()
-				
-				# Call command's invoke with parsed Arguments object and terminal
-				self.command_instance.invoke(arguments, terminal, from_tty)
-				
-			except ValueError as e:
-				# Validation error - show usage
-				print(f"Error: {e}")
-				if self.usage_spec:
-					print()
-					print(self.usage_spec.help_text(command_name))
-			except Exception as e:
-				print(f"Error: {e}")
-				import traceback
-				traceback.print_exc()
-	
-	return RegisteredCommand()
-
-
 def parse_and_eval(expression):
 	"""Evaluate an expression in the debugger.
 	
@@ -690,29 +626,29 @@ def __init__(self):
 
 		def invoke(self, arg, from_tty):
 			"""GDB entry point - parses arguments and delegates to handler."""
+			# Create terminal first (needed for help text)
+			import format
+			terminal = format.create_terminal(from_tty)
+			
 			try:
 				# Parse and validate arguments
 				if self.usage_spec:
-					try:
-						arguments = self.usage_spec.parse(arg if arg else "")
-					except ValueError as e:
-						print(f"Error: {e}")
-						print()
-						print(self.usage_spec.help_text(name))
-						return
+					arguments = self.usage_spec.parse(arg if arg else "")
 				else:
 					# Fallback to basic parsing without validation
 					import command
 					arguments = command.parse_arguments(arg if arg else "")
 
-				# Create terminal for formatting
-				import format
-				terminal = format.create_terminal(from_tty)
-				
 				# Instantiate handler and invoke
 				handler = self.handler_class()
 				handler.invoke(arguments, terminal)
 
+			except ValueError as e:
+				# Validation error - show colored help
+				print(f"Error: {e}")
+				if self.usage_spec:
+					print()
+					print(self.usage_spec.help_text(name, terminal))
 			except Exception as e:
 				print(f"Error: {e}")
 				import traceback

data/toolbox/debugger/lldb_backend.py

@@ -6,6 +6,7 @@
 """
 
 import lldb
+import format
 
 # Command categories (LLDB doesn't have exact equivalents, using symbolic constants)
 COMMAND_DATA = 0
@@ -464,74 +465,6 @@ def get_command(cls, name):
 		return cls._commands.get(name)
 
 
-def register(command_name, command_class, usage=None, category=COMMAND_USER):
-	print(f"DEBUG: Registering command: {command_name} category: {category}")
-	"""Register a command with LLDB using declarative interface.
-	
-	Creates a wrapper that handles argument parsing, validation, and delegation.
-	
-	Args:
-		command_name: Name of the command (e.g., "rb-object-print")
-		command_class: Class to instantiate (must have invoke(arguments, from_tty) method)
-		usage: Optional command.Usage specification for validation and help
-		category: Command category (COMMAND_USER or COMMAND_DATA)
-	
-	Returns:
-		The registered command wrapper instance
-	
-	Example:
-		class RubyObjectPrinter:
-			def invoke(self, arguments, from_tty):
-				value_expr = arguments.expressions[0]
-				depth = arguments.get_option('depth', 1)
-				# ... print logic
-		
-		debugger.register("rb-object-print", RubyObjectPrinter, 
-		                  usage=RubyObjectPrinter.USAGE)
-	"""
-	class RegisteredCommand(Command):
-		def __init__(self):
-			print(f"Registering command: {command_name} category: {category}")
-			super().__init__(command_name, category)
-			self.command_instance = None
-			self.usage_spec = usage
-		
-		def invoke(self, arg, from_tty):
-			try:
-				# Parse and validate arguments
-				if self.usage_spec:
-					arguments = self.usage_spec.parse(arg if arg else "")
-				else:
-					# Fallback: use raw parsing
-					import command as cmd_module
-					arguments = cmd_module.parse_arguments(arg if arg else "")
-				
-				# Create terminal for formatting
-				import format
-				terminal = format.create_terminal(from_tty)
-				
-				# Lazy instantiate command class
-				if self.command_instance is None:
-					self.command_instance = command_class()
-				
-				# Call command's invoke with parsed Arguments object and terminal
-				self.command_instance.invoke(arguments, terminal, from_tty)
-				
-			except ValueError as e:
-				# Validation error - show usage
-				print(f"Error: {e}")
-				if self.usage_spec:
-					print()
-					print(self.usage_spec.help_text(command_name))
-			except Exception as e:
-				print(f"Error: {e}")
-				import traceback
-				traceback.print_exc()
-	
-	print(f"DEBUG: Returning RegisteredCommand for: {command_name}")
-	return RegisteredCommand()
-
-
 def parse_and_eval(expression):
 	"""Evaluate an expression in the debugger.
 	
@@ -990,29 +923,29 @@ def __init__(self):
 
 		def invoke(self, arg, from_tty):
 			"""LLDB entry point - parses arguments and delegates to handler."""
+			# Create terminal first (needed for help text)
+			import format
+			terminal = format.create_terminal(from_tty)
+			
 			try:
 				# Parse and validate arguments
 				if self.usage_spec:
-					try:
-						arguments = self.usage_spec.parse(arg if arg else "")
-					except ValueError as e:
-						print(f"Error: {e}")
-						print()
-						print(self.usage_spec.help_text(name))
-						return
+					arguments = self.usage_spec.parse(arg if arg else "")
 				else:
 					# Fallback to basic parsing without validation
 					import command
 					arguments = command.parse_arguments(arg if arg else "")
 
-				# Create terminal for formatting
-				import format
-				terminal = format.create_terminal(from_tty)
-				
 				# Instantiate handler and invoke
 				handler = self.handler_class()
 				handler.invoke(arguments, terminal)
 
+			except ValueError as e:
+				# Validation error - show colored help
+				print(f"Error: {e}")
+				if self.usage_spec:
+					print()
+					print(self.usage_spec.help_text(name, terminal))
 			except Exception as e:
 				print(f"Error: {e}")
 				import traceback