`96ed1a0`

refactor cleanup stable

Authored by

espadonne 11 months ago

SHA: 96ed1a02229f4686142e8e8c9209e12b1aaaf40a
Parents: 5a0b93c
Tree: 243d149

7 changed files

Status	File	+	-
M	`src/shtick/cli.py`	45	29
M	`src/shtick/commands.py`	113	251
M	`src/shtick/config.py`	110	92
M	`src/shtick/display.py`	147	163
M	`src/shtick/generator.py`	144	226
A	`src/shtick/logger.py`	46	0
M	`src/shtick/shtick.py`	156	162

src/shtick/cli.pymodified

  import argparse
  from shtick.commands import ShtickCommands
  from shtick.display import DisplayCommands
 +from shtick.logger import setup_logging
  def main():
      args = parser.parse_args()
 +    # Set up logging first
 +    logger = setup_logging(debug=args.debug)
++
      if not args.command:
          # Show helpful getting started message
          parser.print_help()
          print("  shtick list                   # List all items")
          sys.exit(1)
 -    # Initialize command handlers
 +    # Initialize command handlers with debug flag
      commands = ShtickCommands(debug=args.debug)
      display = DisplayCommands(debug=args.debug)
      # Route commands
 -    if args.command == "generate":
 -        commands.generate(args.config, args.terse)
 -    elif args.command == "add":
 -        commands.add_item(args.type, args.group, args.assignment)
 -    elif args.command == "add-persistent":
 -        commands.add_persistent(args.type, args.assignment)
 -    elif args.command == "alias":
 -        commands.add_persistent("alias", args.assignment)
 -    elif args.command == "env":
 -        commands.add_persistent("env", args.assignment)
 -    elif args.command == "function":
 -        commands.add_persistent("function", args.assignment)
 -    elif args.command == "remove":
 -        commands.remove_item(args.type, args.group, args.search)
 -    elif args.command == "remove-persistent":
 -        commands.remove_item(args.type, "persistent", args.search)
 -    elif args.command == "activate":
 -        commands.activate_group(args.group)
 -    elif args.command == "deactivate":
 -        commands.deactivate_group(args.group)
 -    elif args.command == "status":
 -        display.status()
 -    elif args.command == "list":
 -        display.list_config(args.long)
 -    elif args.command == "shells":
 -        display.shells(args.long)
 -    elif args.command == "source":
 -        commands.source_command(args.shell)
 +    try:
 +        if args.command == "generate":
 +            commands.generate(args.config, args.terse)
 +        elif args.command == "add":
 +            commands.add_item(args.type, args.group, args.assignment)
 +        elif args.command == "add-persistent":
 +            commands.add_persistent(args.type, args.assignment)
 +        elif args.command == "alias":
 +            commands.add_persistent("alias", args.assignment)
 +        elif args.command == "env":
 +            commands.add_persistent("env", args.assignment)
 +        elif args.command == "function":
 +            commands.add_persistent("function", args.assignment)
 +        elif args.command == "remove":
 +            commands.remove_item(args.type, args.group, args.search)
 +        elif args.command == "remove-persistent":
 +            commands.remove_item(args.type, "persistent", args.search)
 +        elif args.command == "activate":
 +            commands.activate_group(args.group)
 +        elif args.command == "deactivate":
 +            commands.deactivate_group(args.group)
 +        elif args.command == "status":
 +            display.status()
 +        elif args.command == "list":
 +            display.list_config(args.long)
 +        elif args.command == "shells":
 +            display.shells(args.long)
 +        elif args.command == "source":
 +            commands.source_command(args.shell)
++
 +    except KeyboardInterrupt:
 +        logger.debug("Operation cancelled by user")
 +        print("\nCancelled")
 +        sys.exit(1)
 +    except Exception as e:
 +        if args.debug:
 +            logger.exception("Unhandled exception")
 +        else:
 +            logger.error(f"Error: {e}")
 +        sys.exit(1)
  if __name__ == "__main__":

src/shtick/commands.pymodified

  """
 -Command implementations for shtick CLI
 +Command implementations for shtick CLI - REFACTORED to use ShtickManager
  """
  import os
  import sys
  import subprocess
 +import logging
  from typing import Optional, List
 +from shtick.shtick import ShtickManager
  from shtick.config import Config
 -from shtick.generator import Generator
 -from shtick.shells import get_supported_shells
++
 +logger = logging.getLogger("shtick")
  class ShtickCommands:
 -    """Central command handler for shtick operations"""
 +    """Central command handler for shtick operations - now using ShtickManager"""
      def __init__(self, debug: bool = False):
 -        self.debug = debug
 +        # Set up logging based on debug flag
 +        if debug:
 +            logging.basicConfig(
 +                level=logging.DEBUG, format="%(name)s - %(levelname)s - %(message)s"
 +            )
 +        else:
 +            logging.basicConfig(level=logging.INFO, format="%(message)s")
++
 +        self.manager = ShtickManager(debug=debug)
      def get_current_shell(self) -> Optional[str]:
 -        """Detect the current shell"""
 -        shell_path = os.environ.get("SHELL", "")
 -        return os.path.basename(shell_path) if shell_path else None
 +        """Use cached shell detection from Config"""
 +        return Config.get_current_shell()
      def validate_assignment(self, assignment: str) -> tuple[str, str]:
          """Validate key=value assignment format and return key, value"""
          return key, value
 -    def check_conflicts(
 -        self, config: Config, item_type: str, group_name: str, key: str
 -    ) -> List[str]:
 -        """Check for potential conflicts and warn user"""
 -        warnings = []
+-
 -        # Check if item already exists in same group
 -        group = config.get_group(group_name)
 -        if group:
 -            existing_value = None
 -            if item_type == "alias" and key in group.aliases:
 -                existing_value = group.aliases[key]
 -            elif item_type == "env" and key in group.env_vars:
 -                existing_value = group.env_vars[key]
 -            elif item_type == "function" and key in group.functions:
 -                existing_value = group.functions[key]
+-
 -            if existing_value:
 -                warnings.append(
 -                    f"Will overwrite existing {item_type} '{key}' = '{existing_value}' in group '{group_name}'"
 -                )
+-
 -        # Check if item exists in other groups
 -        for other_group in config.groups:
 -            if other_group.name == group_name:
 -                continue
+-
 -            if item_type == "alias" and key in other_group.aliases:
 -                warnings.append(
 -                    f"Alias '{key}' also exists in group '{other_group.name}' = '{other_group.aliases[key]}'"
 -                )
 -            elif item_type == "env" and key in other_group.env_vars:
 -                warnings.append(
 -                    f"Environment variable '{key}' also exists in group '{other_group.name}' = '{other_group.env_vars[key]}'"
 -                )
 -            elif item_type == "function" and key in other_group.functions:
 -                warnings.append(
 -                    f"Function '{key}' also exists in group '{other_group.name}' = '{other_group.functions[key]}'"
 -                )
+-
 -        return warnings
+-
 -    def handle_warnings(self, warnings: List[str]) -> bool:
 -        """Handle conflict warnings and return True if user wants to continue"""
 -        if not warnings:
 -            return True
+-
 -        print("Warnings:")
 -        for warning in warnings:
 -            print(f"  - {warning}")
 -        try:
 -            response = input("Continue anyway? [y/N]: ").strip().lower()
 -            return response in ["y", "yes"]
 -        except (KeyboardInterrupt, EOFError):
 -            print("\nCancelled")
 -            return False
+-
 -    def regenerate_and_offer_source(self, config: Config, group_name: str = None):
 -        """Regenerate shell files and offer auto-sourcing"""
 -        try:
 -            generator = Generator()
+-
 -            if group_name:
 -                group = config.get_group(group_name)
 -                if group:
 -                    generator.generate_for_group(group)
 -            else:
 -                # Regenerate all groups
 -                for group in config.groups:
 -                    generator.generate_for_group(group)
+-
 -            generator.generate_loader(config)
 -            print("✓ Regenerated shell files")
 -            self.offer_auto_source()
 -        except Exception as e:
 -            print(f"Warning: Failed to regenerate files: {e}")
 -            print("Run 'shtick generate' to update shell files")
+-
      def offer_auto_source(self):
          """Offer to source shtick in current shell session"""
          current_shell = self.get_current_shell()
                  .lower()
+             )
              if response in ["", "y", "yes"]:
 -                # Test syntax first
 -                if self._test_loader_syntax(current_shell, loader_path):
 -                    self._show_source_instructions(current_shell)
 +                self._show_source_instructions(current_shell)
          except (KeyboardInterrupt, EOFError):
              print()
 -    def _test_loader_syntax(self, shell: str, loader_path: str) -> bool:
 -        """Test loader file syntax and return True if valid"""
 -        try:
 -            test_response = (
 -                input("Test the loader file for syntax errors? [Y/n]: ").strip().lower()
 -            )
 -            if test_response not in ["", "y", "yes"]:
 -                return True
+-
 -            result = subprocess.run(
 -                [shell, "-c", f'source "{loader_path}"'],
 -                capture_output=True,
 -                text=True,
 -                timeout=5,
 -            )
+-
 -            if result.returncode == 0:
 -                print("✓ Loader file syntax is valid")
 -                return True
 -            else:
 -                print("✗ Loader file has syntax errors:")
 -                print(result.stderr)
 -                print("Please fix the errors before sourcing.")
 -                return False
 -        except subprocess.TimeoutExpired:
 -            print("✓ Loader file appears to work (test timed out, which is normal)")
 -            return True
 -        except Exception as e:
 -            print(f"Could not test loader file: {e}")
 -            return True
+-
      def _show_source_instructions(self, shell: str):
          """Show instructions for sourcing"""
          print(f"\n🎯 Copy and paste this command to load changes immediately:")
                      print(f"✓ Added shtick integration to {config_file}")
                      return True
                  except Exception as e:
 -                    print(f"✗ Failed to modify {config_file}: {e}")
 +                    logger.error(f"Failed to modify {config_file}: {e}")
                      continue
          # If no existing config file found, create the primary one
              print(f"✓ Created {primary_config} with shtick integration")
              return True
          except Exception as e:
 -            print(f"✗ Failed to create {primary_config}: {e}")
 +            logger.error(f"Failed to create {primary_config}: {e}")
              return False
 -    # Command implementations
 +    # Command implementations - now using ShtickManager
      def generate(self, config_path: str = None, terse: bool = False):
          """Generate shell files from config"""
 -        config_path = config_path or Config.get_default_config_path()
+-
          try:
 -            config = Config(config_path, debug=self.debug)
 -            config.load()
+-
 -            generator = Generator()
 -            generator.generate_all(config, interactive=not terse)
 +            if config_path:
 +                # Create a new manager with custom config path
 +                manager = ShtickManager(config_path=config_path)
 +            else:
 +                manager = self.manager
 -            if not terse:
 +            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)
          except FileNotFoundError as e:
              print(f"Error: {e}")
 -            print(f"Create a config file at {config_path} first")
 +            print(f"Create a config file first")
              sys.exit(1)
          except Exception as e:
              print(f"Error: {e}")
              print(f"Error: {e}")
              sys.exit(1)
 -        config_path = Config.get_default_config_path()
+-
 -        try:
 -            config = Config(config_path, debug=self.debug)
 -            try:
 -                config.load()
 -            except FileNotFoundError:
 -                print(f"Creating new config file at {config_path}")
+-
 -            # Check for conflicts and get user confirmation
 -            warnings = self.check_conflicts(config, item_type, group, key)
 -            if not self.handle_warnings(warnings):
 -                return
+-
 -            config.add_item(item_type, group, key, value)
 -            config.save()
 +        # Dispatch to appropriate manager method
 +        if item_type == "alias":
 +            success = self.manager.add_alias(key, value, group)
 +        elif item_type == "env":
 +            success = self.manager.add_env(key, value, group)
 +        elif item_type == "function":
 +            success = self.manager.add_function(key, value, group)
 +        else:
 +            print(f"Error: Unknown item type '{item_type}'")
 +            sys.exit(1)
 +        if success:
              print(f"✓ Added {item_type} '{key}' = '{value}' to group '{group}'")
+-
 -            # Auto-regenerate if group is active
 -            if config.is_group_active(group) or group == "persistent":
 -                self.regenerate_and_offer_source(config, group)
+-
 -        except Exception as e:
 -            print(f"Error: {e}")
 +            # Check if group is active and offer to source
 +            if (
 +                self.manager.get_active_groups()
 +                and group in self.manager.get_active_groups()
 +            ):
 +                self.offer_auto_source()
 +        else:
 +            print(f"Error: Failed to add {item_type}")
              sys.exit(1)
      def add_persistent(self, item_type: str, assignment: str):
              print(f"Error: {e}")
              sys.exit(1)
 -        config_path = Config.get_default_config_path()
 -        is_first_time = not os.path.exists(config_path)
 +        is_first_time = not os.path.exists(Config.get_default_config_path())
 -        try:
 -            config = Config(config_path, debug=self.debug)
 -            try:
 -                config.load()
 -            except FileNotFoundError:
 -                print(f"Creating new config file at {config_path}")
+-
 -            # Check for conflicts
 -            warnings = self.check_conflicts(config, item_type, "persistent", key)
 -            if not self.handle_warnings(warnings):
 -                return
+-
 -            config.add_item(item_type, "persistent", key, value)
 -            config.save()
 +        # Dispatch to appropriate manager method
 +        if item_type == "alias":
 +            success = self.manager.add_persistent_alias(key, value)
 +        elif item_type == "env":
 +            success = self.manager.add_persistent_env(key, value)
 +        elif item_type == "function":
 +            success = self.manager.add_persistent_function(key, value)
 +        else:
 +            print(f"Error: Unknown item type '{item_type}'")
 +            sys.exit(1)
 +        if success:
              print(
                  f"✓ Added {item_type} '{key}' = '{value}' to persistent group (always active)"
+             )
+-
 -            # Auto-regenerate files
 -            self.regenerate_and_offer_source(config, "persistent")
 +            self.offer_auto_source()
              # First-time setup experience
              if is_first_time:
                  print("\n🎉 Welcome to shtick!")
                  self.check_shell_integration()
+-
 -        except Exception as e:
 -            print(f"Error: {e}")
 +        else:
 +            print(f"Error: Failed to add {item_type}")
              sys.exit(1)
      def remove_item(self, item_type: str, group: str, search: str):
          """Remove an item from a group"""
 -        config_path = Config.get_default_config_path()
+-
          try:
 -            config = Config(config_path, debug=self.debug)
 -            config.load()
+-
 -            # Find matching items
 -            matches = config.find_items(item_type, group, search)
 +            # Use manager's list_items to find matches
 +            all_items = self.manager.list_items(group)
 +            matches = [
 +                item["key"]
 +                for item in all_items
 +                if item["type"] == item_type and search.lower() in item["key"].lower()
 +            ]
              if not matches:
                  print(
              if not item_to_remove:
                  return
 -            if config.remove_item(item_type, group, item_to_remove):
 -                config.save()
 -                print(f"✓ Removed {item_type} '{item_to_remove}' from group '{group}'")
 +            # Dispatch to appropriate manager method
 +            if item_type == "alias":
 +                success = self.manager.remove_alias(item_to_remove, group)
 +            elif item_type == "env":
 +                success = self.manager.remove_env(item_to_remove, group)
 +            elif item_type == "function":
 +                success = self.manager.remove_function(item_to_remove, group)
 +            else:
 +                print(f"Error: Unknown item type '{item_type}'")
 +                return
 -                # Auto-regenerate if group is active
 -                if config.is_group_active(group) or group == "persistent":
 -                    self.regenerate_and_offer_source(config, group)
 +            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()
              else:
                  print(f"Failed to remove {item_type} '{item_to_remove}'")
 -        except FileNotFoundError:
 -            print(f"Config file not found: {config_path}")
 -            sys.exit(1)
          except Exception as e:
              print(f"Error: {e}")
              sys.exit(1)
      def activate_group(self, group_name: str):
          """Activate a group"""
 -        config_path = Config.get_default_config_path()
+-
 -        try:
 -            config = Config(config_path, debug=self.debug)
 -            config.load()
+-
 -            if group_name == "persistent":
 -                print(
 -                    "Error: 'persistent' group is always active and cannot be manually activated"
 -                )
 -                return
 +        if group_name == "persistent":
 +            print(
 +                "Error: 'persistent' group is always active and cannot be manually activated"
 +            )
 +            return
 -            if config.activate_group(group_name):
 -                self.regenerate_and_offer_source(config)
 -                print(f"✓ Activated group '{group_name}'")
 -                print("Changes are now active in new shell sessions")
 -            else:
 -                print(f"Error: Group '{group_name}' not found in configuration")
 -                available = [g.name for g in config.get_regular_groups()]
 -                if available:
 -                    print(f"Available groups: {', '.join(available)}")
+-
 -        except FileNotFoundError:
 -            print(f"Config file not found: {config_path}")
 -            print("Run 'shtick generate' first or add some items with 'shtick add'")
 -            sys.exit(1)
 -        except Exception as e:
 -            print(f"Error: {e}")
 -            sys.exit(1)
 +        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()
 +        else:
 +            print(f"Error: Group '{group_name}' not found in configuration")
 +            available = self.manager.get_groups()
 +            if available:
 +                print(f"Available groups: {', '.join(available)}")
      def deactivate_group(self, group_name: str):
          """Deactivate a group"""
 -        config_path = Config.get_default_config_path()
+-
 -        try:
 -            config = Config(config_path, debug=self.debug)
 -            config.load()
+-
 -            if group_name == "persistent":
 -                print("Error: 'persistent' group cannot be deactivated")
 -                return
+-
 -            if config.deactivate_group(group_name):
 -                # Only need to regenerate loader for deactivation
 -                try:
 -                    generator = Generator()
 -                    generator.generate_loader(config)
 -                    print("✓ Regenerated shell files")
 -                except Exception as e:
 -                    print(f"Warning: Failed to regenerate files: {e}")
+-
 -                print(f"✓ Deactivated group '{group_name}'")
 -                print("Changes will take effect in new shell sessions")
 -                self.offer_auto_source()
 -            else:
 -                print(f"Group '{group_name}' was not active")
 +        if group_name == "persistent":
 +            print("Error: 'persistent' group cannot be deactivated")
 +            return
 -        except FileNotFoundError:
 -            print(f"Config file not found: {config_path}")
 -            sys.exit(1)
 -        except Exception as e:
 -            print(f"Error: {e}")
 -            sys.exit(1)
 +        success = self.manager.deactivate_group(group_name)
 +        if success:
 +            print(f"✓ Deactivated group '{group_name}'")
 +            print("Changes will take effect in new shell sessions")
 +            self.offer_auto_source()
 +        else:
 +            print(f"Group '{group_name}' was not active")
      def source_command(self, shell: str = None):
          """Output source command for eval"""

src/shtick/config.pymodified

  """
 -Configuration parsing for shtick
 +Configuration parsing for shtick - REFACTORED
  """
  import os
  import tomllib
 +import logging
  from pathlib import Path
  from dataclasses import dataclass
 -from typing import Dict, List, Optional
 +from typing import Dict, List, Optional, Union
++
 +logger = logging.getLogger("shtick")
  @dataclass
      env_vars: Dict[str, str]
      functions: Dict[str, str]
 +    def get_items(self, item_type: str) -> Dict[str, str]:
 +        """Get items dictionary for the specified type"""
 +        type_map = {"alias": "aliases", "env": "env_vars", "function": "functions"}
 +        attr_name = type_map.get(item_type)
 +        if not attr_name:
 +            raise ValueError(f"Unknown item type: {item_type}")
 +        return getattr(self, attr_name)
++
 +    def set_item(self, item_type: str, key: str, value: str) -> None:
 +        """Set an item in the appropriate dictionary"""
 +        items = self.get_items(item_type)
 +        items[key] = value
++
 +    def remove_item(self, item_type: str, key: str) -> bool:
 +        """Remove an item if it exists"""
 +        items = self.get_items(item_type)
 +        if key in items:
 +            del items[key]
 +            return True
 +        return False
++
 +    def has_item(self, item_type: str, key: str) -> bool:
 +        """Check if an item exists"""
 +        items = self.get_items(item_type)
 +        return key in items
++
 +    def get_item_value(self, item_type: str, key: str) -> Optional[str]:
 +        """Get the value of an item"""
 +        items = self.get_items(item_type)
 +        return items.get(key)
++
 +    @property
 +    def total_items(self) -> int:
 +        """Get total number of items in this group"""
 +        return len(self.aliases) + len(self.env_vars) + len(self.functions)
++
  class Config:
      """Main configuration handler"""
 -    def __init__(self, config_path: Optional[str] = None, debug: bool = False):
 +    # Class variable for shell detection caching
 +    _detected_shell = None
++
 +    def __init__(self, config_path: Optional[str] = None):
          self.config_path = config_path or self.get_default_config_path()
 -        self.debug = debug
          self.groups: List[GroupData] = []
      @staticmethod
          """Get the active groups state file path"""
          return os.path.expanduser("~/.config/shtick/active_groups")
 +    @classmethod
 +    def get_current_shell(cls) -> Optional[str]:
 +        """Detect the current shell with caching"""
 +        if cls._detected_shell is None:
 +            shell_path = os.environ.get("SHELL", "")
 +            cls._detected_shell = os.path.basename(shell_path) if shell_path else ""
 +        return cls._detected_shell if cls._detected_shell else None
++
 +    @classmethod
 +    def clear_shell_cache(cls):
 +        """Clear the cached shell detection (useful for testing)"""
 +        cls._detected_shell = None
++
      def load_active_groups(self) -> List[str]:
          """Load list of currently active groups"""
          active_file = self.get_active_groups_file()
          if not os.path.exists(self.config_path):
              raise FileNotFoundError(f"Config file not found: {self.config_path}")
 -        if self.debug:
 -            print(f"Debug: Loading config from: {self.config_path}")
 +        logger.debug(f"Loading config from: {self.config_path}")
          with open(self.config_path, "rb") as f:
              data = tomllib.load(f)
 -        if self.debug:
 -            print(f"Debug: Raw TOML data keys: {list(data.keys())}")
 -            print(f"Debug: Raw TOML data structure: {data}")
 +        logger.debug(f"Raw TOML data keys: {list(data.keys())}")
          self.groups = []
          # Parse groups from nested TOML structure
          for group_name, group_config in data.items():
 -            if self.debug:
 -                print(
 -                    f"Debug: Processing group '{group_name}' with config: {group_config}"
 -                )
+-
              if not isinstance(group_config, dict):
 -                if self.debug:
 -                    print(f"Debug: Skipping non-dict value for key '{group_name}'")
 +                logger.debug(f"Skipping non-dict value for key '{group_name}'")
                  continue
              # Initialize group data
              # Extract each section from the group
              for section_name, section_data in group_config.items():
 -                if self.debug:
 -                    print(
 -                        f"Debug: Processing section '{section_name}' in group '{group_name}': {section_data}"
 -                    )
+-
                  if section_name == "aliases" and isinstance(section_data, dict):
                      group_data["aliases"] = section_data
 -                    if self.debug:
 -                        print(
 -                            f"Debug: Added {len(section_data)} aliases to '{group_name}'"
 -                        )
 +                    logger.debug(f"Added {len(section_data)} aliases to '{group_name}'")
                  elif section_name == "env_vars" and isinstance(section_data, dict):
                      group_data["env_vars"] = section_data
 -                    if self.debug:
 -                        print(
 -                            f"Debug: Added {len(section_data)} env_vars to '{group_name}'"
 -                        )
 +                    logger.debug(
 +                        f"Added {len(section_data)} env_vars to '{group_name}'"
 +                    )
                  elif section_name == "functions" and isinstance(section_data, dict):
                      group_data["functions"] = section_data
 -                    if self.debug:
 -                        print(
 -                            f"Debug: Added {len(section_data)} functions to '{group_name}'"
 -                        )
 +                    logger.debug(
 +                        f"Added {len(section_data)} functions to '{group_name}'"
 +                    )
                  else:
 -                    if self.debug:
 -                        print(
 -                            f"Debug: Unknown or invalid section '{section_name}' in group '{group_name}'"
 -                        )
 +                    logger.debug(
 +                        f"Unknown or invalid section '{section_name}' in group '{group_name}'"
 +                    )
              # Create GroupData object if group has any items
 -            total_items = (
 -                len(group_data["aliases"])
 -                + len(group_data["env_vars"])
 -                + len(group_data["functions"])
 +            new_group = GroupData(
 +                name=group_name,
 +                aliases=group_data["aliases"],
 +                env_vars=group_data["env_vars"],
 +                functions=group_data["functions"],
+             )
 -            if self.debug:
 -                print(f"Debug: Group '{group_name}' has {total_items} total items")
+-
 -            if total_items > 0:
 -                new_group = GroupData(
 -                    name=group_name,
 -                    aliases=group_data["aliases"],
 -                    env_vars=group_data["env_vars"],
 -                    functions=group_data["functions"],
 -                )
++
 +            if new_group.total_items > 0:
                  self.groups.append(new_group)
 -                if self.debug:
 -                    print(
 -                        f"Debug: Created group '{group_name}' with {len(group_data['aliases'])} aliases, {len(group_data['env_vars'])} env_vars, {len(group_data['functions'])} functions"
 -                    )
 +                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:
 -                if self.debug:
 -                    print(f"Warning: Group '{group_name}' has no items, skipping")
 +                logger.warning(f"Group '{group_name}' has no items, skipping")
 -        if self.debug:
 -            print(
 -                f"Debug: Final groups loaded: {[g.name for g in self.groups]} (total: {len(self.groups)})"
 -            )
 +        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"""
      def add_item(self, item_type: str, group_name: str, key: str, value: str) -> None:
          """Add an alias, env var, or function to a group"""
          group = self.add_group(group_name)
+-
 -        if item_type == "alias":
 -            group.aliases[key] = value
 -        elif item_type == "env":
 -            group.env_vars[key] = value
 -        elif item_type == "function":
 -            group.functions[key] = value
 -        else:
 -            raise ValueError(f"Unknown item type: {item_type}")
 +        group.set_item(item_type, key, value)
      def remove_item(self, item_type: str, group_name: str, key: str) -> bool:
          """Remove an item from a group. Returns True if found and removed."""
          group = self.get_group(group_name)
          if not group:
              return False
+-
 -        if item_type == "alias" and key in group.aliases:
 -            del group.aliases[key]
 -            return True
 -        elif item_type == "env" and key in group.env_vars:
 -            del group.env_vars[key]
 -            return True
 -        elif item_type == "function" and key in group.functions:
 -            del group.functions[key]
 -            return True
+-
 -        return False
 +        return group.remove_item(item_type, key)
      def find_items(
          self, item_type: str, group_name: str, search_term: str
          if not group:
              return []
 -        if item_type == "alias":
 -            items = group.aliases.keys()
 -        elif item_type == "env":
 -            items = group.env_vars.keys()
 -        elif item_type == "function":
 -            items = group.functions.keys()
 -        else:
 -            return []
+-
 +        items = group.get_items(item_type)
          # Simple fuzzy matching - contains search term
 -        return [item for item in items if search_term.lower() in item.lower()]
 +        return [item for item in items.keys() if search_term.lower() in item.lower()]
++
 +    def get_all_shells_to_generate(self) -> List[str]:
 +        """Get list of shells to generate files for based on user settings"""
 +        # For now, just detect current shell and common ones
 +        # Later this can read from settings.toml
 +        current_shell = self.get_current_shell()
 +        if not current_shell:
 +            return ["bash", "zsh", "fish"]  # Common defaults
++
 +        # Include current shell and close relatives
 +        shell_families = {
 +            "bash": ["bash", "sh"],
 +            "zsh": ["zsh", "bash"],
 +            "fish": ["fish"],
 +            "ksh": ["ksh", "bash"],
 +            "dash": ["dash", "sh"],
 +        }
++
 +        shells = shell_families.get(current_shell, [current_shell])
 +        return list(set(shells))  # Remove duplicates

src/shtick/display.pymodified

  import os
  import sys
 +import logging
  from shtick.config import Config
  from shtick.shells import get_supported_shells
 +from shtick.shtick import ShtickManager
++
 +logger = logging.getLogger("shtick")
  class DisplayCommands:
      """Handles all display/listing commands for shtick"""
      def __init__(self, debug: bool = False):
 -        self.debug = debug
 +        # Set up logging
 +        if debug:
 +            logging.basicConfig(
 +                level=logging.DEBUG, format="%(name)s - %(levelname)s - %(message)s"
 +            )
 +        else:
 +            logging.basicConfig(level=logging.INFO, format="%(message)s")
++
 +        self.manager = ShtickManager(debug=debug)
      def get_current_shell(self):
 -        """Detect the current shell"""
 -        shell_path = os.environ.get("SHELL", "")
 -        return os.path.basename(shell_path) if shell_path else None
 +        """Use cached shell detection from Config"""
 +        return Config.get_current_shell()
      def status(self):
          """Show status of groups and active state"""
 -        config_path = Config.get_default_config_path()
 +        status = self.manager.get_status()
 -        try:
 -            config = Config(config_path, debug=self.debug)
 -            config.load()
+-
 -            persistent_group = config.get_persistent_group()
 -            regular_groups = config.get_regular_groups()
 -            active_groups = config.load_active_groups()
+-
 -            print("Shtick Status")
 -            print("=" * 40)
+-
 -            # Show current shell integration status
 -            current_shell = self.get_current_shell()
 -            if current_shell:
 -                print(f"Current shell: {current_shell}")
 -                loader_path = os.path.expanduser(
 -                    f"~/.config/shtick/load_active.{current_shell}"
 -                )
 -                if os.path.exists(loader_path):
 -                    print(f"Loader file: ✓ exists")
 -                else:
 -                    print(f"Loader file: ✗ missing (run 'shtick generate')")
 -            print()
 +        if "error" in status:
 +            print(f"Error loading configuration: {status['error']}")
 +            print("\nGet started with:")
 +            print("  shtick alias ll='ls -la'")
 +            return
 -            # Show persistent group
 -            if persistent_group:
 -                total_persistent = (
 -                    len(persistent_group.aliases)
 -                    + len(persistent_group.env_vars)
 -                    + len(persistent_group.functions)
 -                )
 -                print(f"Persistent (always active): {total_persistent} items")
 +        print("Shtick Status")
 +        print("=" * 40)
++
 +        # Show current shell integration status
 +        if status["current_shell"]:
 +            print(f"Current shell: {status['current_shell']}")
 +            if status["loader_exists"]:
 +                print(f"Loader file: ✓ exists")
              else:
 -                print("Persistent: No items")
 +                print(f"Loader file: ✗ missing (run 'shtick generate')")
 +        print()
 -            print()
 +        # Show persistent group
 +        if status["persistent_items"] > 0:
 +            print(f"Persistent (always active): {status['persistent_items']} items")
 +        else:
 +            print("Persistent: No items")
 -            # Show regular groups
 -            if regular_groups:
 -                print("Available Groups:")
 -                for group in regular_groups:
 -                    status = "ACTIVE" if group.name in active_groups else "inactive"
 -                    total_items = (
 -                        len(group.aliases) + len(group.env_vars) + len(group.functions)
 -                    )
 -                    print(f"  {group.name}: {total_items} items ({status})")
 -            else:
 -                print("No regular groups configured")
 +        print()
 -            print()
 +        # Show regular groups
 +        if status["available_groups"]:
 +            print("Available Groups:")
 +            active_set = set(status["active_groups"])
 +            for group_name in status["available_groups"]:
 +                # Get item count for this group
 +                items = self.manager.list_items(group_name)
 +                item_count = len(items)
 +                status_str = "ACTIVE" if group_name in active_set else "inactive"
 +                print(f"  {group_name}: {item_count} items ({status_str})")
 +        else:
 +            print("No regular groups configured")
 -            # Show summary
 -            if active_groups:
 -                print(f"Currently active: {', '.join(active_groups)}")
 -            else:
 -                print("No groups currently active")
 +        print()
 -            print()
 -            print("Quick commands:")
 -            print("  shtick alias ll='ls -la'              # Add persistent alias")
 -            print("  shtick activate <group>               # Activate group")
 -            print('  eval "$(shtick source)"               # Load changes now')
 +        # Show summary
 +        if status["active_groups"]:
 +            print(f"Currently active: {', '.join(status['active_groups'])}")
 +        else:
 +            print("No groups currently active")
 -        except FileNotFoundError:
 -            print(f"Config file not found: {config_path}")
 -            print("No configuration exists yet")
 -            print("\nGet started with:")
 -            print("  shtick alias ll='ls -la'")
 -        except Exception as e:
 -            print(f"Error: {e}")
 -            sys.exit(1)
 +        print()
 +        print("Quick commands:")
 +        print("  shtick alias ll='ls -la'              # Add persistent alias")
 +        print("  shtick activate <group>               # Activate group")
 +        print('  eval "$(shtick source)"               # Load changes now')
      def list_config(self, long_format: bool = False):
          """List current configuration"""
 -        config_path = Config.get_default_config_path()
 +        items = self.manager.list_items()
 -        try:
 -            config = Config(config_path, debug=self.debug)
 -            config.load()
+-
 -            if not config.groups:
 -                print("No groups configured")
 -                print("\nGet started with:")
 -                print("  shtick alias ll='ls -la'              # Add persistent alias")
 -                print("  shtick add alias work ll='ls -la'     # Add to 'work' group")
 -                print("  shtick activate work                  # Activate 'work' group")
 -                return
+-
 -            persistent_group = config.get_persistent_group()
 -            regular_groups = config.get_regular_groups()
 -            active_groups = config.load_active_groups()
+-
 -            if long_format:
 -                self._print_detailed_list(
 -                    persistent_group, regular_groups, active_groups
 -                )
 -            else:
 -                self._print_tabular_list(
 -                    persistent_group, regular_groups, active_groups
 -                )
+-
 -        except FileNotFoundError:
 -            print(f"Config file not found: {config_path}")
 -            print("Use 'shtick alias <key>=<value>' to create your first alias")
 -        except Exception as e:
 -            print(f"Error: {e}")
 -            sys.exit(1)
+-
 -    def _print_detailed_list(self, persistent_group, regular_groups, active_groups):
 +        if not items:
 +            print("No items configured")
 +            print("\nGet started with:")
 +            print("  shtick alias ll='ls -la'              # Add persistent alias")
 +            print("  shtick add alias work ll='ls -la'     # Add to 'work' group")
 +            print("  shtick activate work                  # Activate 'work' group")
 +            return
++
 +        # Group items by group name
 +        groups_data = {}
 +        for item in items:
 +            group_name = item["group"]
 +            if group_name not in groups_data:
 +                groups_data[group_name] = {
 +                    "aliases": {},
 +                    "env_vars": {},
 +                    "functions": {},
 +                    "active": item["active"],
 +                }
++
 +            if item["type"] == "alias":
 +                groups_data[group_name]["aliases"][item["key"]] = item["value"]
 +            elif item["type"] == "env":
 +                groups_data[group_name]["env_vars"][item["key"]] = item["value"]
 +            elif item["type"] == "function":
 +                groups_data[group_name]["functions"][item["key"]] = item["value"]
++
 +        # Display based on format
 +        if long_format:
 +            self._print_detailed_list(groups_data)
 +        else:
 +            self._print_tabular_list(items)
++
 +    def _print_detailed_list(self, groups_data):
          """Print detailed line-by-line list format"""
 -        # Show persistent group first
 -        if persistent_group:
 +        # Show persistent group first if it exists
 +        if "persistent" in groups_data:
              print("Group: persistent (always active)")
 -            self._print_group_items(persistent_group)
 +            self._print_group_items_detailed(groups_data["persistent"])
              print()
 +            del groups_data["persistent"]
          # Show regular groups
 -        for group in regular_groups:
 -            status = " (ACTIVE)" if group.name in active_groups else " (inactive)"
 -            print(f"Group: {group.name}{status}")
 -            self._print_group_items(group)
 +        for group_name, group_data in sorted(groups_data.items()):
 +            status = " (ACTIVE)" if group_data["active"] else " (inactive)"
 +            print(f"Group: {group_name}{status}")
 +            self._print_group_items_detailed(group_data)
              print()
 -    def _print_group_items(self, group):
 -        """Print items for a single group"""
 -        if group.aliases:
 -            print(f"  Aliases ({len(group.aliases)}):")
 -            for key, value in group.aliases.items():
 +    def _print_group_items_detailed(self, group_data):
 +        """Print items for a single group in detailed format"""
 +        if group_data["aliases"]:
 +            print(f"  Aliases ({len(group_data['aliases'])}):")
 +            for key, value in group_data["aliases"].items():
                  print(f"    {key} = {value}")
 -        if group.env_vars:
 -            print(f"  Environment Variables ({len(group.env_vars)}):")
 -            for key, value in group.env_vars.items():
 +        if group_data["env_vars"]:
 +            print(f"  Environment Variables ({len(group_data['env_vars'])}):")
 +            for key, value in group_data["env_vars"].items():
                  print(f"    {key} = {value}")
 -        if group.functions:
 -            print(f"  Functions ({len(group.functions)}):")
 -            for key, value in group.functions.items():
 +        if group_data["functions"]:
 +            print(f"  Functions ({len(group_data['functions'])}):")
 +            for key, value in group_data["functions"].items():
                  print(f"    {key} = {value}")
 -    def _print_tabular_list(self, persistent_group, regular_groups, active_groups):
 +    def _print_tabular_list(self, items):
          """Print compact tabular list format"""
 -        # Collect all items for tabular display
 -        items = []
+-
 -        # Add persistent items
 -        if persistent_group:
 -            items.extend(self._collect_group_items(persistent_group, "PERSISTENT"))
+-
 -        # Add regular group items
 -        for group in regular_groups:
 -            status = "ACTIVE" if group.name in active_groups else "inactive"
 -            items.extend(self._collect_group_items(group, status))
+-
          if not items:
 -            print("No items configured")
              return
 -        self._print_table(items)
 -        self._print_summary(items, active_groups)
+-
 -    def _collect_group_items(self, group, status):
 -        """Collect items from a group for tabular display"""
 -        items = []
 -        for key, value in group.aliases.items():
 -            items.append((group.name, "alias", key, value, status))
 -        for key, value in group.env_vars.items():
 -            items.append((group.name, "env", key, value, status))
 -        for key, value in group.functions.items():
 -            items.append((group.name, "function", key, value, status))
 -        return items
+-
 -    def _print_table(self, items):
 -        """Print items in tabular format"""
          # Calculate column widths
 -        max_group = max(max(len(item[0]) for item in items), 5)  # "Group"
 -        max_type = max(max(len(item[1]) for item in items), 4)  # "Type"
 -        max_key = max(max(len(item[2]) for item in items), 3)  # "Key"
 +        max_group = max(max(len(item["group"]) for item in items), 5)  # "Group"
 +        max_type = max(max(len(item["type"]) for item in items), 4)  # "Type"
 +        max_key = max(max(len(item["key"]) for item in items), 3)  # "Key"
          max_value = max(
 -            max(min(len(item[3]), 50) for item in items), 5
 +            max(min(len(item["value"]), 50) for item in items), 5
          )  # "Value" (limited)
 -        max_status = max(max(len(item[4]) for item in items), 6)  # "Status"
 +        max_status = max(
 +            max(len("ACTIVE" if item["active"] else "inactive") for item in items), 6
 +        )  # "Status"
          # Print header
          header = f"{'Group':<{max_group}} {'Type':<{max_type}} {'Key':<{max_key}} {'Value':<{max_value}} {'Status':<{max_status}}"
          print(header)
          print("-" * len(header))
 +        # Sort items for better display (persistent first, then by group, then by type)
 +        def sort_key(item):
 +            group_order = 0 if item["group"] == "persistent" else 1
 +            return (group_order, item["group"], item["type"], item["key"])
++
 +        sorted_items = sorted(items, key=sort_key)
++
          # Print items
 -        for group, item_type, key, value, status in items:
 +        for item in sorted_items:
              # Truncate long values with ellipsis
 +            value = item["value"]
              display_value = (
                  value if len(value) <= max_value else value[: max_value - 3] + "..."
+             )
 +            status = "ACTIVE" if item["active"] else "inactive"
              print(
 -                f"{group:<{max_group}} {item_type:<{max_type}} {key:<{max_key}} {display_value:<{max_value}} {status:<{max_status}}"
 +                f"{item['group']:<{max_group}} {item['type']:<{max_type}} "
 +                f"{item['key']:<{max_key}} {display_value:<{max_value}} {status:<{max_status}}"
+             )
 -    def _print_summary(self, items, active_groups):
 +        # Print summary
 +        self._print_summary(items)
++
 +    def _print_summary(self, items):
          """Print summary information"""
          print()
          total_items = len(items)
 -        active_items = len(
 -            [item for item in items if item[4] in ["ACTIVE", "PERSISTENT"]]
 -        )
 +        active_items = len([item for item in items if item["active"]])
          print(f"Total: {total_items} items ({active_items} active)")
          # Show available commands
          print()
          print("Use 'shtick list -l' for detailed view")
 -        if any(item[4] == "inactive" for item in items):
 -            inactive_groups = set(item[0] for item in items if item[4] == "inactive")
++
 +        # Get inactive groups
 +        inactive_groups = set()
 +        for item in items:
 +            if not item["active"] and item["group"] != "persistent":
 +                inactive_groups.add(item["group"])
++
 +        if inactive_groups:
              print(f"Activate groups with: shtick activate <group>")
              print(f"Inactive groups: {', '.join(sorted(inactive_groups))}")

src/shtick/generator.pymodified

  """
  import os
 +import logging
  from pathlib import Path
 -from typing import Dict, List
 +from typing import Dict, List, Set
  from shtick.config import GroupData, Config
 -from shtick.shells import get_supported_shells, get_shell_syntax
 +from shtick.shells import get_shell_syntax
++
 +logger = logging.getLogger("shtick")
  class Generator:
      def __init__(self, output_base_dir: str = None):
          self.output_base_dir = output_base_dir or Config.get_output_dir()
+-
 -    def ensure_output_dir(self, group_name: str, item_type: str) -> str:
 +        # Get shells to generate for once
 +        self._shells_to_generate = None
++
 +    @property
 +    def shells_to_generate(self) -> List[str]:
 +        """Get list of shells to generate files for"""
 +        if self._shells_to_generate is None:
 +            config = Config()
 +            self._shells_to_generate = config.get_all_shells_to_generate()
 +            logger.debug(f"Will generate files for shells: {self._shells_to_generate}")
 +        return self._shells_to_generate
++
 +    def ensure_output_dir(self, group_name: str) -> str:
          """Ensure output directory exists and return the path"""
 -        output_dir = os.path.join(self.output_base_dir, group_name, item_type)
 +        output_dir = os.path.join(self.output_base_dir, group_name)
          Path(output_dir).mkdir(parents=True, exist_ok=True)
          return output_dir
      def generate_for_group(self, group: GroupData) -> None:
          """Generate all shell files for a single group"""
 -        print(f"Processing group: {group.name}")
 +        logger.info(f"Processing group: {group.name}")
 -        # Generate aliases
 -        if group.aliases:
 -            print(f"  Generating alias files ({len(group.aliases)} aliases)")
 -            self._generate_files(group.name, "alias", group.aliases, "aliases")
 +        # Skip if group is empty
 +        if group.total_items == 0:
 +            logger.debug(f"Skipping empty group: {group.name}")
 +            return
 -        # Generate env vars
 -        if group.env_vars:
 -            print(f"  Generating env var files ({len(group.env_vars)} variables)")
 -            self._generate_files(group.name, "env", group.env_vars, "envvars")
 +        # Prepare all content for the group
 +        group_content = self._prepare_group_content(group)
 -        # Generate functions
 -        if group.functions:
 -            print(f"  Generating function files ({len(group.functions)} functions)")
 -            self._generate_files(group.name, "function", group.functions, "functions")
 +        # Generate consolidated files for each shell
 +        output_dir = self.ensure_output_dir(group.name)
 +        for shell_name in self.shells_to_generate:
 +            self._generate_group_file(shell_name, group.name, group_content, output_dir)
 -    def _generate_files(
 -        self, group_name: str, item_type: str, items: Dict[str, str], prefix: str
 +    def _prepare_group_content(self, group: GroupData) -> Dict[str, Dict[str, str]]:
 +        """Prepare all content for a group organized by type"""
 +        return {
 +            "alias": group.aliases,
 +            "env": group.env_vars,
 +            "function": group.functions,
 +        }
++
 +    def _generate_group_file(
 +        self,
 +        shell_name: str,
 +        group_name: str,
 +        content: Dict[str, Dict[str, str]],
 +        output_dir: str,
      ) -> None:
 -        """Generate shell files for a specific item type"""
 -        output_dir = self.ensure_output_dir(group_name, item_type)
+-
 -        # Generate for each supported shell + default
 -        all_shells = get_supported_shells() + ["default"]
+-
 -        for shell_name in all_shells:
 -            shell_syntax = get_shell_syntax(shell_name)
 -            filename = f"{prefix}.{shell_name}"
 -            filepath = os.path.join(output_dir, filename)
+-
 -            with open(filepath, "w") as f:
 -                # Write header
 -                f.write(f"# {prefix} for {shell_name}\n")
 -                f.write("# Generated by shtick\n\n")
+-
 -                # Write items using appropriate syntax
 -                for key, value in items.items():
 -                    if item_type == "alias":
 -                        line = shell_syntax.alias_fmt.format(key, value)
 -                    elif item_type == "env":
 -                        line = shell_syntax.env_fmt.format(key, value)
 -                    elif item_type == "function":
 -                        line = shell_syntax.function_fmt.format(key, value)
 -                    else:
 -                        continue
 +        """Generate a single consolidated file for a shell"""
 +        shell_syntax = get_shell_syntax(shell_name)
++
 +        # Count total items
 +        total_items = sum(len(items) for items in content.values())
 +        if total_items == 0:
 +            return
++
 +        logger.debug(
 +            f"Generating {shell_name} file for group {group_name} ({total_items} items)"
 +        )
++
 +        # Create consolidated file
 +        filename = f"all.{shell_name}"
 +        filepath = os.path.join(output_dir, filename)
++
 +        with open(filepath, "w") as f:
 +            # Write header
 +            f.write(f"# Shtick configuration for {group_name} - {shell_name}\n")
 +            f.write("# Generated by shtick\n\n")
++
 +            # Write aliases
 +            if content["alias"]:
 +                f.write(f"# Aliases ({len(content['alias'])})\n")
 +                for key, value in content["alias"].items():
 +                    line = shell_syntax.alias_fmt.format(key, value)
 +                    f.write(line)
 +                f.write("\n")
++
 +            # Write env vars
 +            if content["env"]:
 +                f.write(f"# Environment Variables ({len(content['env'])})\n")
 +                for key, value in content["env"].items():
 +                    line = shell_syntax.env_fmt.format(key, value)
 +                    f.write(line)
 +                f.write("\n")
 +            # Write functions
 +            if content["function"]:
 +                f.write(f"# Functions ({len(content['function'])})\n")
 +                for key, value in content["function"].items():
 +                    line = shell_syntax.function_fmt.format(key, value)
                      f.write(line)
 +                f.write("\n")
      def generate_all(self, config: Config, interactive: bool = True) -> None:
          """Generate shell files for all groups in config"""
              return
          print(f"Generating shell files for {len(config.groups)} groups...")
 +        print(f"Target shells: {', '.join(self.shells_to_generate)}")
          for group in config.groups:
              self.generate_for_group(group)
          # Generate the dynamic loader for all shells
          self.generate_loader(config)
 -        print(f"All done! Files generated in {self.output_base_dir}")
 -        self._print_usage_instructions(config, interactive)
 +        print(f"\n✓ All done! Files generated in {self.output_base_dir}")
++
 +        if interactive:
 +            self._print_usage_instructions(config)
      def generate_loader(self, config: Config) -> None:
          """Generate dynamic loader files that source persistent + active groups"""
 -        print("Generating dynamic loader files...")
 +        logger.info("Generating dynamic loader files...")
          active_groups = config.load_active_groups()
          persistent_group = config.get_persistent_group()
 -        # Generate for each supported shell + default
 -        all_shells = get_supported_shells() + ["default"]
+-
 -        for shell_name in all_shells:
 +        for shell_name in self.shells_to_generate:
              loader_path = os.path.join(
                  self.output_base_dir, f"load_active.{shell_name}"
+             )
                  f.write("# This file is auto-generated - do not edit\n\n")
                  # Source persistent group first (always active)
 -                if persistent_group:
 +                if persistent_group and persistent_group.total_items > 0:
                      f.write("# Load persistent configuration\n")
 -                    for item_type in ["alias", "env", "function"]:
 -                        # Map item_type to the actual filename prefix
 -                        prefix_map = {
 -                            "alias": "aliases",
 -                            "env": "envvars",
 -                            "function": "functions",
 -                        }
 -                        prefix = prefix_map[item_type]
 -                        file_path = f"$HOME/.config/shtick/persistent/{item_type}/{prefix}.{shell_name}"
 -                        f.write(f'[ -f "{file_path}" ] && source "{file_path}"\n')
 -                    f.write("\n")
 +                    file_path = f"$HOME/.config/shtick/persistent/all.{shell_name}"
 +                    f.write(f'[ -f "{file_path}" ] && source "{file_path}"\n\n')
                  # Source active groups
                  if active_groups:
                      f.write("# Load active groups\n")
                      for group_name in active_groups:
 -                        f.write(f"# Group: {group_name}\n")
 -                        for item_type in ["alias", "env", "function"]:
 -                            # Map item_type to the actual filename prefix
 -                            prefix_map = {
 -                                "alias": "aliases",
 -                                "env": "envvars",
 -                                "function": "functions",
 -                            }
 -                            prefix = prefix_map[item_type]
 -                            file_path = f"$HOME/.config/shtick/{group_name}/{item_type}/{prefix}.{shell_name}"
 +                        group = config.get_group(group_name)
 +                        if group and group.total_items > 0:
 +                            f.write(f"# Group: {group_name}\n")
 +                            file_path = (
 +                                f"$HOME/.config/shtick/{group_name}/all.{shell_name}"
 +                            )
                              f.write(f'[ -f "{file_path}" ] && source "{file_path}"\n')
 -                        f.write("\n")
 +                    f.write("\n")
                  else:
                      f.write("# No active groups\n")
 -    def _print_usage_instructions(
 -        self, config: Config, interactive: bool = True
 -    ) -> None:
 +    def _print_usage_instructions(self, config: Config) -> None:
          """Print usage instructions for the user"""
          active_groups = config.load_active_groups()
          persistent_group = config.get_persistent_group()
+-
 -        if interactive:
 -            self._interactive_shell_setup()
 +        current_shell = Config.get_current_shell()
++
 +        print("\nUsage Instructions:")
 +        print("=" * 50)
++
 +        if current_shell and current_shell in self.shells_to_generate:
 +            print(f"\nFor {current_shell}, add this to your shell config:")
 +            loader_path = f"~/.config/shtick/load_active.{current_shell}"
++
 +            shell_configs = {
 +                "bash": "~/.bashrc",
 +                "zsh": "~/.zshrc",
 +                "fish": "~/.config/fish/config.fish",
 +                "ksh": "~/.kshrc",
 +                "dash": "~/.dashrc",
 +            }
++
 +            config_file = shell_configs.get(current_shell, "your shell config")
 +            print(f"  # In {config_file}:")
 +            print(f"  source {loader_path}")
          else:
 -            self._print_default_instructions()
 +            # Fallback instructions
 +            print("\nAdd the appropriate line to your shell config:")
 +            for shell in self.shells_to_generate[:3]:  # Show top 3
 +                print(f"  # For {shell}:")
 +                print(f"  source ~/.config/shtick/load_active.{shell}")
++
 +        print("\n" + "=" * 50)
 +        # Status summary
          if persistent_group:
 -            total_persistent = (
 -                len(persistent_group.aliases)
 -                + len(persistent_group.env_vars)
 -                + len(persistent_group.functions)
 +            print(
 +                f"\nPersistent items (always active): {persistent_group.total_items} total"
+             )
 -            print(f"\nPersistent items (always active): {total_persistent} total")
          if active_groups:
              print(f"Active groups: {', '.join(active_groups)}")
          if available_groups:
              print(f"Available groups: {', '.join(available_groups)}")
 -    def _print_default_instructions(self) -> None:
 -        """Print default sourcing instructions"""
 -        print("\nTo use these configurations, add this line to your shell config:")
 -        print("  # For bash/zsh (~/.bashrc or ~/.zshrc):")
 -        print("  source ~/.config/shtick/load_active.bash")
 -        print("\n  # For fish (~/.config/fish/config.fish):")
 -        print("  source ~/.config/shtick/load_active.fish")
+-
 -    def _interactive_shell_setup(self) -> None:
 -        """Interactive shell selection for sourcing instructions"""
 -        from shtick.shells import get_supported_shells
+-
 -        print("\nSelect shells to show sourcing instructions for:")
 -        print("(You can specify multiple shells by number or name, space-separated)")
 -        print()
+-
 -        shells = sorted(get_supported_shells())
 -        shell_configs = {
 -            "bash": ("~/.bashrc", "source ~/.config/shtick/load_active.bash"),
 -            "zsh": ("~/.zshrc", "source ~/.config/shtick/load_active.zsh"),
 -            "fish": (
 -                "~/.config/fish/config.fish",
 -                "source ~/.config/shtick/load_active.fish",
 -            ),
 -            "ksh": ("~/.kshrc", "source ~/.config/shtick/load_active.ksh"),
 -            "mksh": ("~/.mkshrc", "source ~/.config/shtick/load_active.mksh"),
 -            "yash": ("~/.yashrc", "source ~/.config/shtick/load_active.yash"),
 -            "dash": ("~/.dashrc", "source ~/.config/shtick/load_active.dash"),
 -            "csh": ("~/.cshrc", "source ~/.config/shtick/load_active.csh"),
 -            "tcsh": ("~/.tcshrc", "source ~/.config/shtick/load_active.tcsh"),
 -            "xonsh": ("~/.xonshrc", "source ~/.config/shtick/load_active.xonsh"),
 -            "elvish": (
 -                "~/.elvish/rc.elv",
 -                "source ~/.config/shtick/load_active.elvish",
 -            ),
 -            "nushell": (
 -                "~/.config/nushell/config.nu",
 -                "source ~/.config/shtick/load_active.nushell",
 -            ),
 -            "powershell": ("$PROFILE", ". ~/.config/shtick/load_active.powershell"),
 -            "rc": ("~/.rcrc", "source ~/.config/shtick/load_active.rc"),
 -            "es": ("~/.esrc", "source ~/.config/shtick/load_active.es"),
 -            "oil": ("~/.oilrc", "source ~/.config/shtick/load_active.oil"),
 -        }
+-
 -        # Display numbered list
 -        for i, shell in enumerate(shells, 1):
 -            config_file = shell_configs.get(
 -                shell, ("~/.profile", f"source ~/.config/shtick/load_active.{shell}")
 -            )[0]
 -            print(f"  {i:2d}. {shell:<12} ({config_file})")
+-
 -        print(f"  {len(shells)+1:2d}. all          (show all shells)")
 -        print()
+-
 -        try:
 -            user_input = input(
 -                "Enter shell numbers or names (space-separated): "
 -            ).strip()
 -            if not user_input:
 -                print("No selection made, skipping sourcing instructions.")
 -                return
+-
 -            selected_shells = self._parse_shell_selection(user_input, shells)
+-
 -            if not selected_shells:
 -                print("No valid shells selected, skipping sourcing instructions.")
 -                return
+-
 -            print("\nAdd these lines to your shell configuration files:")
 -            print("=" * 60)
+-
 -            for shell in selected_shells:
 -                config_file, source_line = shell_configs.get(
 -                    shell,
 -                    ("~/.profile", f"source ~/.config/shtick/load_active.{shell}"),
 -                )
+-
 -                print(f"\n# {shell.upper()}")
 -                print(f"# File: {config_file}")
 -                print(f"{source_line}")
+-
 -            print("\n" + "=" * 60)
+-
 -        except (KeyboardInterrupt, EOFError):
 -            print("\nCancelled. Skipping sourcing instructions.")
+-
 -    def _parse_shell_selection(
 -        self, user_input: str, available_shells: List[str]
 -    ) -> List[str]:
 -        """Parse user input for shell selection (numbers or names)"""
 -        selected = set()
 -        tokens = user_input.lower().split()
+-
 -        for token in tokens:
 -            # Check if it's "all"
 -            if token == "all":
 -                return available_shells
+-
 -            # Check if it's a number
 -            try:
 -                num = int(token)
 -                if 1 <= num <= len(available_shells):
 -                    selected.add(available_shells[num - 1])
 -                elif num == len(available_shells) + 1:  # "all" option
 -                    return available_shells
 -                else:
 -                    print(f"Warning: Invalid number {num}, ignoring")
 -                continue
 -            except ValueError:
 -                pass
+-
 -            # Check if it's a shell name (fuzzy match)
 -            matches = [shell for shell in available_shells if token in shell.lower()]
 -            if len(matches) == 1:
 -                selected.add(matches[0])
 -            elif len(matches) > 1:
 -                print(
 -                    f"Warning: '{token}' matches multiple shells: {', '.join(matches)}"
 -                )
 -                print(f"Using exact match or first match: {matches[0]}")
 -                selected.add(matches[0])
 -            else:
 -                print(f"Warning: No shell matches '{token}', ignoring")
+-
 -        return sorted(list(selected))
+-
 -    def get_shell_files_for_group(self, group_name: str) -> Dict[str, List[str]]:
 +    def get_shell_files_for_group(self, group_name: str) -> List[str]:
          """Get list of generated shell files for a group"""
 -        files = {"alias": [], "env": [], "function": []}
+-
 -        for item_type in files.keys():
 -            type_dir = os.path.join(self.output_base_dir, group_name, item_type)
 -            if os.path.exists(type_dir):
 -                files[item_type] = [
 -                    os.path.join(type_dir, f)
 -                    for f in os.listdir(type_dir)
 -                    if os.path.isfile(os.path.join(type_dir, f))
 -                ]
 +        group_dir = os.path.join(self.output_base_dir, group_name)
 +        if not os.path.exists(group_dir):
 +            return []
++
 +        files = []
 +        for shell in self.shells_to_generate:
 +            file_path = os.path.join(group_dir, f"all.{shell}")
 +            if os.path.exists(file_path):
 +                files.append(file_path)
          return files

src/shtick/logger.pyadded

 +"""
 +Logging configuration for shtick
 +"""
++
 +import logging
 +import sys
++
++
 +def setup_logging(debug: bool = False, name: str = "shtick") -> logging.Logger:
 +    """
 +    Set up logging configuration for shtick.
++
 +    Args:
 +        debug: Enable debug logging
 +        name: Logger name
++
 +    Returns:
 +        Configured logger instance
 +    """
 +    logger = logging.getLogger(name)
++
 +    # Clear any existing handlers to avoid duplicates
 +    logger.handlers.clear()
++
 +    # Create console handler
 +    handler = logging.StreamHandler(sys.stdout)
++
 +    # Set level and format based on debug flag
 +    if debug:
 +        logger.setLevel(logging.DEBUG)
 +        formatter = logging.Formatter(
 +            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
 +            datefmt="%Y-%m-%d %H:%M:%S",
 +        )
 +    else:
 +        logger.setLevel(logging.INFO)
 +        # Simple format for non-debug - just the message
 +        formatter = logging.Formatter("%(message)s")
++
 +    handler.setFormatter(formatter)
 +    logger.addHandler(handler)
++
 +    # Prevent propagation to root logger
 +    logger.propagate = False
++
 +    return logger

src/shtick/shtick.pymodified

  """
  import os
 -from typing import List, Dict, Optional, Union
 +import logging
 +from typing import List, Dict, Optional, Union, Tuple
  from .config import Config, GroupData
  from .generator import Generator
 -from .commands import ShtickCommands
++
 +logger = logging.getLogger("shtick")
  class ShtickManager:
              debug: Enable debug output
          """
          self.config_path = config_path or Config.get_default_config_path()
 -        self.debug = debug
++
 +        # Set up logging
 +        if debug:
 +            logging.basicConfig(
 +                level=logging.DEBUG, format="%(name)s - %(levelname)s - %(message)s"
 +            )
 +        else:
 +            logging.basicConfig(level=logging.INFO, format="%(message)s")
++
          self._config = None
 -        self._commands = ShtickCommands(debug=debug)
 +        self._generator = Generator()
      def _load_config(self, create_if_missing: bool = True) -> Config:
          """Load or reload the configuration"""
          try:
 -            config = Config(self.config_path, debug=self.debug)
 +            config = Config(self.config_path)
              config.load()
              self._config = config
              return config
          except FileNotFoundError:
              if create_if_missing:
 +                logger.debug("Creating new config file")
                  # Create empty config
 -                config = Config(self.config_path, debug=self.debug)
 +                config = Config(self.config_path)
                  config.ensure_config_dir()
                  config.save()
                  self._config = config
              return self._load_config()
          return self._config
 -    def _save_and_regenerate(self) -> None:
 +    def _save_and_regenerate(self, affected_groups: Optional[List[str]] = None) -> None:
          """Save config and regenerate shell files"""
          config = self._get_config()
          config.save()
 -        # Regenerate shell files
 -        generator = Generator()
 +        # Regenerate shell files for affected groups
 +        if affected_groups:
 +            for group_name in affected_groups:
 +                group = config.get_group(group_name)
 +                if group:
 +                    self._generator.generate_for_group(group)
 +        else:
 +            # Regenerate all
 +            for group in config.groups:
 +                self._generator.generate_for_group(group)
++
 +        # Always regenerate loader
 +        self._generator.generate_loader(config)
++
 +    def check_conflicts(
 +        self, item_type: str, key: str, group_name: str
 +    ) -> List[Tuple[str, str]]:
 +        """
 +        Check for conflicts across all groups.
++
 +        Returns:
 +            List of tuples (group_name, existing_value) for conflicts
 +        """
 +        config = self._get_config()
 +        conflicts = []
++
          for group in config.groups:
 -            generator.generate_for_group(group)
 -        generator.generate_loader(config)
 +            if group.has_item(item_type, key):
 +                existing_value = group.get_item_value(item_type, key)
 +                conflicts.append((group.name, existing_value))
++
 +        return conflicts
      # Alias management
 -    def add_persistent_alias(self, key: str, value: str) -> bool:
 +    def add_persistent_alias(
 +        self, key: str, value: str, check_conflicts: bool = True
 +    ) -> bool:
          """
          Add a persistent alias (always active).
          Args:
              key: Alias name
              value: Alias command
 +            check_conflicts: Whether to check for conflicts
          Returns:
              True if successful
+-
 -        Example:
 -            >>> manager.add_persistent_alias('ll', 'ls -la')
 -            True
          """
 -        try:
 -            config = self._get_config()
 -            config.add_item("alias", "persistent", key, value)
 -            self._save_and_regenerate()
 -            return True
 -        except Exception as e:
 -            if self.debug:
 -                print(f"Error adding persistent alias: {e}")
 -            return False
 +        return self._add_item("alias", "persistent", key, value, check_conflicts)
 -    def add_alias(self, key: str, value: str, group: str) -> bool:
 +    def add_alias(
 +        self, key: str, value: str, group: str, check_conflicts: bool = True
 +    ) -> bool:
          """
          Add an alias to a specific group.
              key: Alias name
              value: Alias command
              group: Group name
 +            check_conflicts: Whether to check for conflicts
          Returns:
              True if successful
          """
 -        try:
 -            config = self._get_config()
 -            config.add_item("alias", group, key, value)
 -            self._save_and_regenerate()
 -            return True
 -        except Exception as e:
 -            if self.debug:
 -                print(f"Error adding alias: {e}")
 -            return False
 +        return self._add_item("alias", group, key, value, check_conflicts)
      def remove_alias(self, key: str, group: str = "persistent") -> bool:
          """
          Returns:
              True if successful
          """
 -        try:
 -            config = self._get_config()
 -            success = config.remove_item("alias", group, key)
 -            if success:
 -                self._save_and_regenerate()
 -            return success
 -        except Exception as e:
 -            if self.debug:
 -                print(f"Error removing alias: {e}")
 -            return False
 +        return self._remove_item("alias", group, key)
      # Environment variable management
 -    def add_persistent_env(self, key: str, value: str) -> bool:
 +    def add_persistent_env(
 +        self, key: str, value: str, check_conflicts: bool = True
 +    ) -> bool:
          """
          Add a persistent environment variable (always active).
          Args:
              key: Variable name
              value: Variable value
 +            check_conflicts: Whether to check for conflicts
          Returns:
              True if successful
          """
 -        try:
 -            config = self._get_config()
 -            config.add_item("env", "persistent", key, value)
 -            self._save_and_regenerate()
 -            return True
 -        except Exception as e:
 -            if self.debug:
 -                print(f"Error adding persistent env var: {e}")
 -            return False
 +        return self._add_item("env", "persistent", key, value, check_conflicts)
 -    def add_env(self, key: str, value: str, group: str) -> bool:
 +    def add_env(
 +        self, key: str, value: str, group: str, check_conflicts: bool = True
 +    ) -> bool:
          """
          Add an environment variable to a specific group.
              key: Variable name
              value: Variable value
              group: Group name
 +            check_conflicts: Whether to check for conflicts
          Returns:
              True if successful
          """
 -        try:
 -            config = self._get_config()
 -            config.add_item("env", group, key, value)
 -            self._save_and_regenerate()
 -            return True
 -        except Exception as e:
 -            if self.debug:
 -                print(f"Error adding env var: {e}")
 -            return False
 +        return self._add_item("env", group, key, value, check_conflicts)
      def remove_env(self, key: str, group: str = "persistent") -> bool:
          """
          Returns:
              True if successful
          """
 -        try:
 -            config = self._get_config()
 -            success = config.remove_item("env", group, key)
 -            if success:
 -                self._save_and_regenerate()
 -            return success
 -        except Exception as e:
 -            if self.debug:
 -                print(f"Error removing env var: {e}")
 -            return False
 +        return self._remove_item("env", group, key)
      # Function management
 -    def add_persistent_function(self, key: str, value: str) -> bool:
 +    def add_persistent_function(
 +        self, key: str, value: str, check_conflicts: bool = True
 +    ) -> bool:
          """
          Add a persistent function (always active).
          Args:
              key: Function name
              value: Function body
 +            check_conflicts: Whether to check for conflicts
          Returns:
              True if successful
          """
 -        try:
 -            config = self._get_config()
 -            config.add_item("function", "persistent", key, value)
 -            self._save_and_regenerate()
 -            return True
 -        except Exception as e:
 -            if self.debug:
 -                print(f"Error adding persistent function: {e}")
 -            return False
 +        return self._add_item("function", "persistent", key, value, check_conflicts)
 -    def add_function(self, key: str, value: str, group: str) -> bool:
 +    def add_function(
 +        self, key: str, value: str, group: str, check_conflicts: bool = True
 +    ) -> bool:
          """
          Add a function to a specific group.
              key: Function name
              value: Function body
              group: Group name
 +            check_conflicts: Whether to check for conflicts
          Returns:
              True if successful
          """
 -        try:
 -            config = self._get_config()
 -            config.add_item("function", group, key, value)
 -            self._save_and_regenerate()
 -            return True
 -        except Exception as e:
 -            if self.debug:
 -                print(f"Error adding function: {e}")
 -            return False
 +        return self._add_item("function", group, key, value, check_conflicts)
      def remove_function(self, key: str, group: str = "persistent") -> bool:
          """
          Returns:
              True if successful
          """
 +        return self._remove_item("function", group, key)
++
 +    # Generic item management
 +    def _add_item(
 +        self,
 +        item_type: str,
 +        group_name: str,
 +        key: str,
 +        value: str,
 +        check_conflicts: bool,
 +    ) -> bool:
 +        """Generic method to add any item type"""
 +        try:
 +            config = self._get_config()
++
 +            # Check for conflicts if requested
 +            if check_conflicts:
 +                conflicts = self.check_conflicts(item_type, key, group_name)
 +                if conflicts:
 +                    logger.warning(
 +                        f"Item '{key}' exists in groups: {[c[0] for c in conflicts]}"
 +                    )
 +                    # Still proceed but warn
++
 +            config.add_item(item_type, group_name, key, value)
++
 +            # Only regenerate files for affected group if it's active
 +            affected_groups = []
 +            if group_name == "persistent" or config.is_group_active(group_name):
 +                affected_groups.append(group_name)
++
 +            self._save_and_regenerate(affected_groups)
 +            return True
++
 +        except Exception as e:
 +            logger.error(f"Error adding {item_type}: {e}")
 +            return False
++
 +    def _remove_item(self, item_type: str, group_name: str, key: str) -> bool:
 +        """Generic method to remove any item type"""
          try:
              config = self._get_config()
 -            success = config.remove_item("function", group, key)
 +            success = config.remove_item(item_type, group_name, key)
++
              if success:
 -                self._save_and_regenerate()
 +                # Only regenerate if group is active
 +                affected_groups = []
 +                if group_name == "persistent" or config.is_group_active(group_name):
 +                    affected_groups.append(group_name)
++
 +                self._save_and_regenerate(affected_groups)
++
              return success
++
          except Exception as e:
 -            if self.debug:
 -                print(f"Error removing function: {e}")
 +            logger.error(f"Error removing {item_type}: {e}")
              return False
      # Group management
              config = self._get_config()
              success = config.activate_group(group)
              if success:
 -                generator = Generator()
 -                generator.generate_loader(config)
 +                self._generator.generate_loader(config)
              return success
          except Exception as e:
 -            if self.debug:
 -                print(f"Error activating group: {e}")
 +            logger.error(f"Error activating group: {e}")
              return False
      def deactivate_group(self, group: str) -> bool:
              config = self._get_config()
              success = config.deactivate_group(group)
              if success:
 -                generator = Generator()
 -                generator.generate_loader(config)
 +                self._generator.generate_loader(config)
              return success
          except Exception as e:
 -            if self.debug:
 -                print(f"Error deactivating group: {e}")
 +            logger.error(f"Error deactivating group: {e}")
              return False
      def get_active_groups(self) -> List[str]:
              regular_groups = config.get_regular_groups()
              active_groups = config.load_active_groups()
 -            current_shell = os.path.basename(os.environ.get("SHELL", ""))
 +            current_shell = Config.get_current_shell() or ""
              loader_exists = False
              if current_shell:
                  loader_path = os.path.expanduser(
+                 )
                  loader_exists = os.path.exists(loader_path)
 -            persistent_count = 0
 -            if persistent_group:
 -                persistent_count = (
 -                    len(persistent_group.aliases)
 -                    + len(persistent_group.env_vars)
 -                    + len(persistent_group.functions)
 -                )
 +            persistent_count = persistent_group.total_items if persistent_group else 0
              return {
                  "current_shell": current_shell,
              groups_to_check = [g for g in groups_to_check if g is not None]
              for g in groups_to_check:
 -                # Add aliases
 -                for key, value in g.aliases.items():
 -                    items.append(
 -                        {
 -                            "group": g.name,
 -                            "type": "alias",
 -                            "key": key,
 -                            "value": value,
 -                            "active": config.is_group_active(g.name)
 -                            or g.name == "persistent",
 -                        }
 -                    )
+-
 -                # Add env vars
 -                for key, value in g.env_vars.items():
 -                    items.append(
 -                        {
 -                            "group": g.name,
 -                            "type": "env",
 -                            "key": key,
 -                            "value": value,
 -                            "active": config.is_group_active(g.name)
 -                            or g.name == "persistent",
 -                        }
 -                    )
+-
 -                # Add functions
 -                for key, value in g.functions.items():
 -                    items.append(
 -                        {
 -                            "group": g.name,
 -                            "type": "function",
 -                            "key": key,
 -                            "value": value,
 -                            "active": config.is_group_active(g.name)
 -                            or g.name == "persistent",
 -                        }
 -                    )
 +                # Process each item type
 +                for item_type in ["alias", "env", "function"]:
 +                    item_dict = g.get_items(item_type)
 +                    for key, value in item_dict.items():
 +                        items.append(
 +                            {
 +                                "group": g.name,
 +                                "type": item_type,
 +                                "key": key,
 +                                "value": value,
 +                                "active": config.is_group_active(g.name)
 +                                or g.name == "persistent",
 +                            }
 +                        )
              return items
          except Exception as e:
 -            if self.debug:
 -                print(f"Error listing items: {e}")
 +            logger.error(f"Error listing items: {e}")
              return []
      def generate_shell_files(self) -> bool:
          """
          try:
              config = self._get_config()
 -            generator = Generator()
 -            for group in config.groups:
 -                generator.generate_for_group(group)
 -            generator.generate_loader(config)
 +            self._generator.generate_all(config, interactive=False)
              return True
          except Exception as e:
 -            if self.debug:
 -                print(f"Error generating shell files: {e}")
 +            logger.error(f"Error generating shell files: {e}")
              return False
      def get_source_command(self, shell: Optional[str] = None) -> Optional[str]:
              Source command string or None if not available
          """
          try:
 -            current_shell = shell or os.path.basename(os.environ.get("SHELL", ""))
 +            current_shell = shell or Config.get_current_shell()
              if not current_shell:
                  return None