`23d0de2`

extend group functionality

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 11 months ago

SHA: 23d0de20878dbd5724098e7f0454dce33ec7baea
Parents: cceeb7c
Tree: 5bf7284

5 changed files

Status	File	+	-
M	`src/shtick/cli.py`	67	1
M	`src/shtick/commands.py`	168	55
M	`src/shtick/config.py`	69	31
M	`src/shtick/security.py`	31	7
M	`src/shtick/shtick.py`	88	0

src/shtick/cli.pymodified

          help="Show one shell per line instead of columns",
+     )
 +    # Add group management commands
 +    group_parser = subparsers.add_parser("group", help="Group management commands")
 +    group_subparsers = group_parser.add_subparsers(
 +        dest="group_command", help="Group commands"
 +    )
++
 +    # Create group
 +    create_parser = group_subparsers.add_parser("create", help="Create a new group")
 +    create_parser.add_argument("name", help="Group name")
 +    create_parser.add_argument("-d", "--description", help="Group description")
++
 +    # Remove group
 +    remove_parser = group_subparsers.add_parser("remove", help="Remove a group")
 +    remove_parser.add_argument("name", help="Group name")
 +    remove_parser.add_argument(
 +        "-f", "--force", action="store_true", help="Force removal without confirmation"
 +    )
++
 +    # Rename group
 +    rename_parser = group_subparsers.add_parser("rename", help="Rename a group")
 +    rename_parser.add_argument("old_name", help="Current group name")
 +    rename_parser.add_argument("new_name", help="New group name")
++
 +    # Backup commands
 +    backup_parser = subparsers.add_parser("backup", help="Backup management commands")
 +    backup_subparsers = backup_parser.add_subparsers(
 +        dest="backup_command", help="Backup commands"
 +    )
++
 +    # Create backup
 +    backup_create_parser = backup_subparsers.add_parser(
 +        "create", help="Create a backup"
 +    )
 +    backup_create_parser.add_argument(
 +        "-n", "--name", help="Backup name (timestamp used if not provided)"
 +    )
++
 +    # List backups
 +    backup_list_parser = backup_subparsers.add_parser(
 +        "list", help="List available backups"
 +    )
++
 +    # Restore backup
 +    backup_restore_parser = backup_subparsers.add_parser(
 +        "restore", help="Restore from backup"
 +    )
 +    backup_restore_parser.add_argument("name", help="Backup name or filename")
++
      # Source command (for eval)
      source_parser = subparsers.add_parser(
          "source", help="Output source command for eval (for immediate loading)"
                  commands.settings_set(args.key, args.value)
              else:
                  settings_parser.print_help()
 +        elif args.command == "group":
 +            if args.group_command == "create":
 +                commands.group_create(args.name, args.description)
 +            elif args.group_command == "rename":
 +                commands.group_rename(args.old_name, args.new_name)
 +            elif args.group_command == "remove":
 +                commands.group_remove(args.name, args.force)
 +            else:
 +                group_parser.print_help()
 +        elif args.command == "backup":
 +            if args.backup_command == "create":
 +                commands.backup_create(args.name)
 +            elif args.backup_command == "list":
 +                commands.backup_list()
 +            elif args.backup_command == "restore":
 +                commands.backup_restore(args.name)
 +            else:
 +                backup_parser.print_help()
      except KeyboardInterrupt:
          logger.debug("Operation cancelled by user")
          print("\nCancelled")
 -        sys.exit(1)
 +        sys.exit(2)  # Use exit code 2 for user cancellation
      except Exception as e:
          if args.debug:
              logger.exception("Unhandled exception")

src/shtick/commands.pymodified

  """
 -Command implementations for shtick CLI - REFACTORED to use ShtickManager
 +Command implementations for shtick CLI - FIXED WITH CONSISTENT RETURN STATUSES
  """
  import os
  class ShtickCommands:
 -    """Central command handler for shtick operations - now using ShtickManager"""
 +    """Central command handler for shtick operations - with consistent return codes"""
      def __init__(self, debug: bool = False):
          # Set up logging based on debug flag
          self.manager = ShtickManager(debug=debug)
 +    def _exit_error(self, message: str, code: int = 1):
 +        """Print error message and exit with given code"""
 +        print(f"Error: {message}")
 +        sys.exit(code)
++
 +    def _exit_success(self, message: str = None, code: int = 0):
 +        """Print optional success message and exit with code"""
 +        if message:
 +            print(message)
 +        sys.exit(code)
++
      def get_current_shell(self) -> Optional[str]:
          """Use cached shell detection from Config"""
          return Config.get_current_shell()
              logger.error(f"Failed to create {primary_config}: {e}")
              return False
 -    # Command implementations - now using ShtickManager
 +    # Command implementations - now with consistent return statuses
      def generate(self, config_path: str = None, terse: bool = False):
          """Generate shell files from config"""
          try:
              if config_path:
 -                # Validate path for security
 -                validated_path = validate_config_path(config_path)
 +                # Validate path for security with relaxed rules for generate
 +                validated_path = validate_config_path(config_path, for_generate=True)
++
 +                # Warn about custom config behavior
 +                if not terse:
 +                    print("Note: Generating from custom config file")
 +                    print("This will overwrite files but won't affect active groups")
++
                  # Create a new manager with custom config path
                  manager = ShtickManager(config_path=validated_path)
              else:
                  manager = self.manager
              success = manager.generate_shell_files()
 -            if success and not terse:
 -                self.check_shell_integration()
 -            elif not success:
 -                print("Error: Failed to generate shell files")
 -                sys.exit(1)
 +            if success:
 +                if not terse:
 +                    self.check_shell_integration()
 +                self._exit_success()  # Explicit success
 +            else:
 +                self._exit_error("Failed to generate shell files")
          except FileNotFoundError as e:
 -            print(f"Error: {e}")
 -            print(f"Create a config file first")
 -            sys.exit(1)
 +            self._exit_error(f"{e}\nCreate a config file first")
          except Exception as e:
 -            print(f"Error: {e}")
 -            sys.exit(1)
 +            self._exit_error(str(e))
      def add_item(self, item_type: str, group: str, assignment: str):
          """Add an item to a specific group"""
          try:
              key, value = self.validate_assignment(assignment)
          except ValueError as e:
 -            print(f"Error: {e}")
 -            sys.exit(1)
 +            self._exit_error(str(e))
          # Dispatch to appropriate manager method
          if item_type == "alias":
          elif item_type == "function":
              success = self.manager.add_function(key, value, group)
          else:
 -            print(f"Error: Unknown item type '{item_type}'")
 -            sys.exit(1)
 +            self._exit_error(f"Unknown item type '{item_type}'")
          if success:
              print(f"✓ Added {item_type} '{key}' = '{value}' to group '{group}'")
                  and group in self.manager.get_active_groups()
              ):
                  self.offer_auto_source()
 +            self._exit_success()  # Explicit success
          else:
 -            print(f"Error: Failed to add {item_type}")
 -            sys.exit(1)
 +            self._exit_error(f"Failed to add {item_type}")
      def add_persistent(self, item_type: str, assignment: str):
          """Add an item to the persistent group"""
          try:
              key, value = self.validate_assignment(assignment)
          except ValueError as e:
 -            print(f"Error: {e}")
 -            sys.exit(1)
 +            self._exit_error(str(e))
          is_first_time = not os.path.exists(Config.get_default_config_path())
          elif item_type == "function":
              success = self.manager.add_persistent_function(key, value)
          else:
 -            print(f"Error: Unknown item type '{item_type}'")
 -            sys.exit(1)
 +            self._exit_error(f"Unknown item type '{item_type}'")
          if success:
              print(
              if is_first_time:
                  print("\n🎉 Welcome to shtick!")
                  self.check_shell_integration()
++
 +            self._exit_success()  # Explicit success
          else:
 -            print(f"Error: Failed to add {item_type}")
 -            sys.exit(1)
 +            self._exit_error(f"Failed to add {item_type}")
      def remove_item(self, item_type: str, group: str, search: str):
          """Remove an item from a group"""
                  print(
                      f"No {item_type} items matching '{search}' found in group '{group}'"
+                 )
 -                return
 +                self._exit_success()  # Not an error - nothing to remove
              # Handle single vs multiple matches
              item_to_remove = self._select_item_to_remove(matches)
              if not item_to_remove:
 -                return
 +                self._exit_success()  # User cancelled - not an error
              # Dispatch to appropriate manager method
              if item_type == "alias":
              elif item_type == "function":
                  success = self.manager.remove_function(item_to_remove, group)
              else:
 -                print(f"Error: Unknown item type '{item_type}'")
 -                return
 +                self._exit_error(f"Unknown item type '{item_type}'")
              if success:
                  print(f"✓ Removed {item_type} '{item_to_remove}' from group '{group}'")
                  # Offer to source if group is active
                  if group == "persistent" or group in self.manager.get_active_groups():
                      self.offer_auto_source()
 +                self._exit_success()  # Explicit success
              else:
 -                print(f"Failed to remove {item_type} '{item_to_remove}'")
 +                self._exit_error(f"Failed to remove {item_type} '{item_to_remove}'")
          except Exception as e:
 -            print(f"Error: {e}")
 -            sys.exit(1)
 +            self._exit_error(str(e))
      def _select_item_to_remove(self, matches: List[str]) -> Optional[str]:
          """Handle selection of item to remove from matches"""
      def activate_group(self, group_name: str):
          """Activate a group"""
          if group_name == "persistent":
 -            print(
 -                "Error: 'persistent' group is always active and cannot be manually activated"
 +            self._exit_error(
 +                "'persistent' group is always active and cannot be manually activated"
+             )
 -            return
          success = self.manager.activate_group(group_name)
          if success:
              print(f"✓ Activated group '{group_name}'")
              print("Changes are now active in new shell sessions")
              self.offer_auto_source()
 +            self._exit_success()  # Explicit success
          else:
 -            print(f"Error: Group '{group_name}' not found in configuration")
              available = self.manager.get_groups()
              if available:
 -                print(f"Available groups: {', '.join(available)}")
 +                self._exit_error(
 +                    f"Group '{group_name}' not found. Available groups: {', '.join(available)}"
 +                )
 +            else:
 +                self._exit_error(f"Group '{group_name}' not found in configuration")
      def deactivate_group(self, group_name: str):
          """Deactivate a group"""
          if group_name == "persistent":
 -            print("Error: 'persistent' group cannot be deactivated")
 -            return
 +            self._exit_error("'persistent' group cannot be deactivated")
          success = self.manager.deactivate_group(group_name)
          if success:
              self.offer_auto_source()
          else:
              print(f"Group '{group_name}' was not active")
 +            # Not an error - deactivating inactive group is idempotent
++
 +        self._exit_success()  # Always exit success for idempotent operation
      def source_command(self, shell: str = None):
          """Output source command for eval"""
          # Output the source command that can be eval'd
          print(f"source {loader_path}")
 +        self._exit_success()  # Explicit success
      # Settings commands
      def settings_init(self):
+                 )
                  if response not in ["y", "yes"]:
                      print("Cancelled")
 -                    return
 +                    self._exit_success()  # User cancelled - not an error
              except (KeyboardInterrupt, EOFError):
                  print("\nCancelled")
 -                return
 +                self._exit_error("Operation cancelled by user", code=2)
          settings.create_default_settings_file()
          print(f"✓ Created settings file at {settings._settings_path}")
          print("\nYou can now customize your shtick behavior by editing this file.")
 +        self._exit_success()  # Explicit success
      def settings_show(self):
          """Show current settings"""
              print("(No settings file found - using defaults)")
              print("Run 'shtick settings init' to create one")
 +        self._exit_success()  # Explicit success
++
      def settings_set(self, key: str, value: str):
          """Set a specific setting value"""
          from shtick.settings import Settings
          # Parse the key (e.g., "generation.shells")
          parts = key.split(".")
          if len(parts) != 2:
 -            print(
 -                f"Error: Invalid key format. Use 'section.key' (e.g., 'generation.shells')"
 +            self._exit_error(
 +                "Invalid key format. Use 'section.key' (e.g., 'generation.shells')"
+             )
 -            sys.exit(1)
          section, setting_key = parts
          # Validate section
          if section not in ["generation", "behavior", "performance"]:
 -            print(
 -                f"Error: Invalid section '{section}'. Must be one of: generation, behavior, performance"
 +            self._exit_error(
 +                f"Invalid section '{section}'. Must be one of: generation, behavior, performance"
+             )
 -            sys.exit(1)
          # Get the section object
          section_obj = getattr(settings, section)
          if not hasattr(section_obj, setting_key):
              print(f"Error: Invalid key '{setting_key}' for section '{section}'")
              print(f"Valid keys: {', '.join(vars(section_obj).keys())}")
 -            sys.exit(1)
 +            self._exit_error(f"Invalid key '{setting_key}'")
          # Parse the value based on type
          current_value = getattr(section_obj, setting_key)
                  # String value
                  parsed_value = value
          except Exception as e:
 -            print(f"Error parsing value: {e}")
 -            sys.exit(1)
 +            self._exit_error(f"Error parsing value: {e}")
          # Set the value
          setattr(section_obj, setting_key, parsed_value)
          # Save settings
 -        settings.save()
 +        try:
 +            settings.save()
 +            print(f"✓ Set {key} = {parsed_value}")
 +            print(f"Settings saved to {settings._settings_path}")
 +            self._exit_success()  # Explicit success
 +        except Exception as e:
 +            self._exit_error(f"Failed to save settings: {e}")
++
 +    # Group management commands
 +    def group_create(self, name: str, description: str = None):
 +        """Create a new group"""
 +        try:
 +            # Check if group already exists
 +            if self.manager.get_groups() and name in self.manager.get_groups():
 +                self._exit_error(f"Group '{name}' already exists")
++
 +            # Actually create the empty group
 +            from shtick.config import Config, GroupData
++
 +            config = self.manager._get_config()
++
 +            # Add the new empty group
 +            new_group = GroupData(name=name, aliases={}, env_vars={}, functions={})
 +            config.groups.append(new_group)
++
 +            # Save the config with the new empty group
 +            config.save()
++
 +            print(f"✓ Created group '{name}'")
 +            print(f"\nAdd items to this group with:")
 +            print(f"  shtick add alias {name} ll='ls -la'")
 +            print(f"  shtick add env {name} DEBUG=1")
 +            print(f"\nActivate with:")
 +            print(f"  shtick activate {name}")
++
 +            self._exit_success()
 +        except Exception as e:
 +            self._exit_error(str(e))
++
 +    def group_rename(self, old_name: str, new_name: str):
 +        """Rename a group"""
 +        # This would require refactoring the config to support renaming
 +        # For now, just indicate it's not implemented
 +        self._exit_error("Group rename is not yet implemented")
++
 +    def group_remove(self, name: str, force: bool = False):
 +        """Remove a group"""
 +        # This would require refactoring the config to support group removal
 +        # For now, just indicate it's not implemented
 +        self._exit_error("Group removal is not yet implemented")
++
 +    # Backup commands
 +    def backup_create(self, name: str = None):
 +        """Create a backup"""
 +        try:
 +            backup_path = self.manager.backup_config(name)
 +            print(f"✓ Created backup: {backup_path}")
 +            self._exit_success()
 +        except Exception as e:
 +            self._exit_error(f"Failed to create backup: {e}")
++
 +    def backup_list(self):
 +        """List available backups"""
 +        try:
 +            backups = self.manager.list_backups()
 +            if not backups:
 +                print("No backups found")
 +            else:
 +                print("Available backups:")
 +                for backup in backups:
 +                    from datetime import datetime
++
 +                    mtime = datetime.fromtimestamp(backup["modified"]).strftime(
 +                        "%Y-%m-%d %H:%M:%S"
 +                    )
 +                    size_kb = backup["size"] / 1024
 +                    print(f"  {backup['name']} ({size_kb:.1f} KB, modified: {mtime})")
 +            self._exit_success()
 +        except Exception as e:
 +            self._exit_error(f"Failed to list backups: {e}")
++
 +    def backup_restore(self, name: str):
 +        """Restore from backup"""
 +        try:
 +            if self.manager.restore_backup(name):
 +                print(f"✓ Restored from backup: {name}")
 +                print("Run 'shtick generate' to regenerate shell files")
 +                self._exit_success()
 +            else:
 +                self._exit_error(f"Backup '{name}' not found")
 +        except Exception as e:
 +            self._exit_error(f"Failed to restore backup: {e}")
++
 -        print(f"✓ Set {key} = {parsed_value}")
 -        print(f"Settings saved to {settings._settings_path}")
 +# Return code conventions:
 +# 0 - Success
 +# 1 - General error (invalid arguments, missing files, etc.)
 +# 2 - User cancelled operation
 +# 3 - Permission denied (currently not used, but reserved)
 +# 4 - Resource not found when it should exist (currently not used, but reserved)

src/shtick/config.pymodified

          data = {}
          for group in groups:
              group_data = {}
 -            if group.aliases:
 -                group_data["aliases"] = group.aliases
 -            if group.env_vars:
 -                group_data["env_vars"] = group.env_vars
 -            if group.functions:
 -                group_data["functions"] = group.functions
 -            if group_data:
 -                data[group.name] = group_data
 +            # Always include the sections, even if empty
 +            group_data["aliases"] = group.aliases if group.aliases else {}
 +            group_data["env_vars"] = group.env_vars if group.env_vars else {}
 +            group_data["functions"] = group.functions if group.functions else {}
 +            data[group.name] = group_data
          with open(config_path, "wb") as f:
              tomli_w.dump(data, f)
      except ImportError:
 -        # Fallback with proper escaping
 -        data = {}
 -        for group in groups:
 -            if group.aliases:
 -                data[f"{group.name}.aliases"] = group.aliases
 -            if group.env_vars:
 -                data[f"{group.name}.env_vars"] = group.env_vars
 -            if group.functions:
 -                data[f"{group.name}.functions"] = group.functions
+-
 -        # Write TOML manually with proper escaping
 +        # Enhanced fallback that writes proper nested TOML structure
          with open(config_path, "w") as f:
 -            # Sort sections for consistent output
 -            for section in sorted(data.keys()):
 -                items = data[section]
 -                f.write(f"[{section}]\n")
 -                # Sort items within section
 -                for key in sorted(items.keys()):
 -                    value = items[key]
 -                    # Use proper TOML escaping
 +            # Write each group
 +            for group in groups:
 +                # Write main group header
 +                f.write(f"[{group.name}]\n")
++
 +                # Write aliases section
 +                f.write(f"[{group.name}.aliases]\n")
 +                for key in sorted(group.aliases.keys()):
 +                    value = group.aliases[key]
                      escaped_value = escape_toml_value(value)
                      f.write(f"{key} = {escaped_value}\n")
 -                f.write("\n")
++
 +                # Write env_vars section
 +                f.write(f"\n[{group.name}.env_vars]\n")
 +                for key in sorted(group.env_vars.keys()):
 +                    value = group.env_vars[key]
 +                    escaped_value = escape_toml_value(value)
 +                    f.write(f"{key} = {escaped_value}\n")
++
 +                # Write functions section
 +                f.write(f"\n[{group.name}.functions]\n")
 +                for key in sorted(group.functions.keys()):
 +                    value = group.functions[key]
 +                    escaped_value = escape_toml_value(value)
 +                    f.write(f"{key} = {escaped_value}\n")
++
 +                f.write("\n")  # Empty line between groups
  @dataclass
                          f"Unknown or invalid section '{section_name}' in group '{group_name}'"
+                     )
 -            # Create GroupData object if group has any items
 +            # Create GroupData object (allow empty groups)
              new_group = GroupData(
                  name=group_name,
                  aliases=group_data["aliases"],
                  functions=group_data["functions"],
+             )
 +            # Always add the group, even if empty
 +            self.groups.append(new_group)
++
              if new_group.total_items > 0:
 -                self.groups.append(new_group)
                  logger.debug(
                      f"Created group '{group_name}' with {len(group_data['aliases'])} aliases, "
                      f"{len(group_data['env_vars'])} env_vars, {len(group_data['functions'])} functions"
+                 )
              else:
 -                logger.warning(f"Group '{group_name}' has no items, skipping")
 +                logger.debug(f"Created empty group '{group_name}'")
          logger.debug(
              f"Final groups loaded: {[g.name for g in self.groups]} (total: {len(self.groups)})"
      def save(self) -> None:
          """Save the current configuration back to TOML file with secure escaping"""
 +        # Check if we should backup
 +        from .settings import Settings
++
 +        settings = Settings()
++
 +        if settings.behavior.backup_on_save and os.path.exists(self.config_path):
 +            # Create automatic backup
 +            from datetime import datetime
++
 +            backup_dir = os.path.join(os.path.dirname(self.config_path), "backups")
 +            os.makedirs(backup_dir, exist_ok=True)
++
 +            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
 +            backup_path = os.path.join(backup_dir, f"config_auto_{timestamp}.toml")
++
 +            import shutil
++
 +            shutil.copy2(self.config_path, backup_path)
 +            logger.debug(f"Created automatic backup: {backup_path}")
++
 +            # Clean up old auto backups (keep last 10)
 +            auto_backups = sorted(
 +                [
 +                    f
 +                    for f in os.listdir(backup_dir)
 +                    if f.startswith("config_auto_") and f.endswith(".toml")
 +                ]
 +            )
 +            if len(auto_backups) > 10:
 +                for old_backup in auto_backups[:-10]:
 +                    os.remove(os.path.join(backup_dir, old_backup))
++
 +        # Save normally
          save_config_securely(self.config_path, self.groups)
      def get_group(self, group_name: str) -> Optional[GroupData]:

src/shtick/security.pymodified

  """
 -Security validation functions for shtick
 +Security validation functions for shtick - FIXED FOR GENERATE COMMAND
  """
  import os
          raise ValueError(f"Value too long: maximum {max_length} characters")
 -def validate_config_path(path: str) -> str:
 +def validate_config_path(path: str, for_generate: bool = False) -> str:
      """
      Validate and sanitize config path for security.
      Args:
          path: Path to validate
 +        for_generate: If True, use relaxed validation for generate command
      Returns:
          Validated absolute path
          if ".." in path:
              raise ValueError("Directory traversal detected")
 +        # Ensure .toml extension
 +        if resolved.suffix != ".toml":
 +            raise ValueError("Config file must have .toml extension")
++
 +        # For generate command, use relaxed validation
 +        if for_generate:
 +            # Just ensure the file exists and isn't in system directories
 +            if not resolved.exists():
 +                raise ValueError("Config file not found")
++
 +            # Still block system directories
 +            if any(
 +                resolved_str.startswith(forbidden)
 +                for forbidden in FORBIDDEN_SYSTEM_PATHS
 +            ):
 +                raise ValueError("Access to system directories is forbidden")
++
 +            return resolved_str
++
 +        # For other commands, use strict validation
          # Block system directories
          if any(
              resolved_str.startswith(forbidden) for forbidden in FORBIDDEN_SYSTEM_PATHS
          ):
 -            raise ValueError(f"Access to system directories is forbidden")
 +            raise ValueError("Access to system directories is forbidden")
          # Ensure it's under user's home or current directory
          home = Path.home()
          cwd = Path.cwd()
 +        # Check both the original home and current home (for tests)
 +        original_home = os.environ.get("SHTICK_ORIGINAL_HOME")
 +        if original_home:
 +            original_home_path = Path(original_home)
 +            if resolved.is_relative_to(original_home_path):
 +                return resolved_str
++
          if not (resolved.is_relative_to(home) or resolved.is_relative_to(cwd)):
              raise ValueError("Config path must be under home or current directory")
 -        # Ensure .toml extension
 -        if resolved.suffix != ".toml":
 -            raise ValueError("Config file must have .toml extension")
+-
          return resolved_str
      except Exception as e:

src/shtick/shtick.pymodified

              logger.error(f"Error generating shell files: {e}")
              return False
 +    def backup_config(self, backup_name: str = None) -> str:
 +        """Create a backup of current configuration"""
 +        import shutil
 +        from datetime import datetime
++
 +        config = self._get_config()
 +        backup_dir = os.path.join(os.path.dirname(config.config_path), "backups")
 +        os.makedirs(backup_dir, exist_ok=True)
++
 +        if backup_name:
 +            backup_filename = f"config_{backup_name}.toml"
 +        else:
 +            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
 +            backup_filename = f"config_backup_{timestamp}.toml"
++
 +        backup_path = os.path.join(backup_dir, backup_filename)
++
 +        # Copy current config
 +        if os.path.exists(config.config_path):
 +            shutil.copy2(config.config_path, backup_path)
 +            return backup_path
 +        else:
 +            raise FileNotFoundError("No config file to backup")
++
 +    def list_backups(self) -> List[Dict[str, str]]:
 +        """List all available backups"""
 +        config = self._get_config()
 +        backup_dir = os.path.join(os.path.dirname(config.config_path), "backups")
++
 +        if not os.path.exists(backup_dir):
 +            return []
++
 +        backups = []
 +        for file in sorted(os.listdir(backup_dir), reverse=True):
 +            if file.endswith(".toml"):
 +                file_path = os.path.join(backup_dir, file)
 +                stat = os.stat(file_path)
 +                backups.append(
 +                    {
 +                        "name": file,
 +                        "path": file_path,
 +                        "size": stat.st_size,
 +                        "modified": stat.st_mtime,
 +                    }
 +                )
++
 +        return backups
++
 +    def restore_backup(self, backup_name: str) -> bool:
 +        """Restore configuration from a backup"""
 +        import shutil
++
 +        config = self._get_config()
 +        backup_dir = os.path.join(os.path.dirname(config.config_path), "backups")
++
 +        # Find backup file - try multiple naming patterns
 +        backup_path = None
 +        possible_names = [
 +            backup_name,  # exact name
 +            f"{backup_name}.toml",  # add extension
 +            f"config_{backup_name}",  # add prefix
 +            f"config_{backup_name}.toml",  # add both
 +        ]
++
 +        for name in possible_names:
 +            full_path = os.path.join(backup_dir, name)
 +            if os.path.exists(full_path):
 +                backup_path = full_path
 +                break
++
 +        if not backup_path:
 +            return False
++
 +        # Create backup of current before restoring
 +        try:
 +            self.backup_config("before_restore")
 +        except:
 +            pass  # Current config might not exist
++
 +        # Restore
 +        shutil.copy2(backup_path, config.config_path)
++
 +        # Reload config and regenerate
 +        self._load_config(create_if_missing=False)
 +        self.generate_shell_files()
++
 +        return True
++
      def get_source_command(self, shell: Optional[str] = None) -> Optional[str]:
          """
          Get the source command for loading shtick in current session.