`63edf82`

refactor

Authored by

espadonne 11 months ago

SHA: 63edf82430248db97f82097f39ccf18e7a5b75e6
Parents: fb3e924
Tree: c7cf71f

3 changed files

Status	File	+	-
M	`src/shtick/cli.py`	56	597
A	`src/shtick/commands.py`	543	0
A	`src/shtick/display.py`	283	0

src/shtick/cli.pymodified

  import sys
  import argparse
--import os
++from shtick.commands import ShtickCommands
--from typing import Optional
++from shtick.display import DisplayCommands
--
--# Package imports
--from shtick.config import Config
--from shtick.generator import Generator
--from shtick.shells import get_supported_shells
--
--
--def cmd_generate(args) -> None:
--    """Generate shell files from config"""
--    config_path = args.config or Config.get_default_config_path()
--
--    try:
--        config = Config(config_path, debug=args.debug)
--        config.load()
--
--        generator = Generator()
--        generator.generate_all(config, interactive=not args.terse)
--
--    except FileNotFoundError as e:
--        print(f"Error: {e}")
--        print(f"Create a config file at {config_path} first")
--        sys.exit(1)
--    except Exception as e:
--        print(f"Error: {e}")
--        sys.exit(1)
--
--
--def cmd_add(args) -> None:
--    """Add an item to the config"""
--    if "=" not in args.assignment:
--        print("Error: Assignment must be in format key=value")
--        sys.exit(1)
--
--    key, value = args.assignment.split("=", 1)
--    key = key.strip()
--    value = value.strip()
--
--    if not key or not value:
--        print("Error: Both key and value must be non-empty")
--        sys.exit(1)
--
--    config_path = Config.get_default_config_path()
--
--    try:
--        config = Config(config_path, debug=getattr(args, "debug", False))
--        # Try to load existing config, create empty if doesn't exist
--        try:
--            config.load()
--        except FileNotFoundError:
--            print(f"Creating new config file at {config_path}")
--
--        config.add_item(args.type, args.group, key, value)
--        config.save()
--
--        print(f"Added {args.type} '{key}' = '{value}' to group '{args.group}'")
--
--    except Exception as e:
--        print(f"Error: {e}")
--        sys.exit(1)
--
--
--def cmd_add_persistent(args) -> None:
--    """Add an item to the persistent group"""
--    if "=" not in args.assignment:
--        print("Error: Assignment must be in format key=value")
--        sys.exit(1)
--
--    key, value = args.assignment.split("=", 1)
--    key = key.strip()
--    value = value.strip()
--
--    if not key or not value:
--        print("Error: Both key and value must be non-empty")
--        sys.exit(1)
--
--    config_path = Config.get_default_config_path()
--
--    try:
--        config = Config(config_path, debug=getattr(args, "debug", False))
--        # Try to load existing config, create empty if doesn't exist
--        try:
--            config.load()
--        except FileNotFoundError:
--            print(f"Creating new config file at {config_path}")
--
--        config.add_item(args.type, "persistent", key, value)
--        config.save()
--
--        print(
--            f"Added {args.type} '{key}' = '{value}' to persistent group (always active)"
--        )
--
--        # Auto-regenerate files if they exist
--        try:
--            generator = Generator()
--            persistent_group = config.get_persistent_group()
--            if persistent_group:
--                generator.generate_for_group(persistent_group)
--                generator.generate_loader(config)
--                print("Regenerated shell files with new persistent item")
--        except Exception as e:
--            print(f"Warning: Failed to regenerate files: {e}")
--            print("Run 'shtick generate' to update shell files")
--
--    except Exception as e:
--        print(f"Error: {e}")
--        sys.exit(1)
--
--
--def cmd_remove(args) -> None:
--    """Remove an item from the config"""
--    config_path = Config.get_default_config_path()
--
--    try:
--        config = Config(config_path, debug=getattr(args, "debug", False))
--        config.load()
--
--        # Find matching items
--        matches = config.find_items(args.type, args.group, args.search)
--
--        if not matches:
--            print(
--                f"No {args.type} items matching '{args.search}' found in group '{args.group}'"
--            )
--            return
--
--        if len(matches) == 1:
--            # Exact match, remove it
--            item = matches[0]
--            if config.remove_item(args.type, args.group, item):
--                config.save()
--                print(f"Removed {args.type} '{item}' from group '{args.group}'")
--            else:
--                print(f"Failed to remove {args.type} '{item}'")
--        else:
--            # Multiple matches, ask for confirmation
--            print(f"Found {len(matches)} matches:")
--            for i, item in enumerate(matches, 1):
--                print(f"  {i}. {item}")
--
--            try:
--                choice = input("Enter number to remove (or 'q' to quit): ").strip()
--                if choice.lower() == "q":
--                    print("Cancelled")
--                    return
--
--                idx = int(choice) - 1
--                if 0 <= idx < len(matches):
--                    item = matches[idx]
--                    if config.remove_item(args.type, args.group, item):
--                        config.save()
--                        print(f"Removed {args.type} '{item}' from group '{args.group}'")
--                    else:
--                        print(f"Failed to remove {args.type} '{item}'")
--                else:
--                    print("Invalid choice")
--            except (ValueError, KeyboardInterrupt):
--                print("\nCancelled")
--
--    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 cmd_remove_persistent(args) -> None:
--    """Remove an item from the persistent group"""
--    config_path = Config.get_default_config_path()
--
--    try:
--        config = Config(config_path, debug=getattr(args, "debug", False))
--        config.load()
--
--        # Find matching items in persistent group
--        matches = config.find_items(args.type, "persistent", args.search)
--
--        if not matches:
--            print(
--                f"No {args.type} items matching '{args.search}' found in persistent group"
--            )
--            return
--
--        if len(matches) == 1:
--            # Exact match, remove it
--            item = matches[0]
--            if config.remove_item(args.type, "persistent", item):
--                config.save()
--                print(f"Removed {args.type} '{item}' from persistent group")
--
--                # Auto-regenerate files
--                try:
--                    generator = Generator()
--                    persistent_group = config.get_persistent_group()
--                    if persistent_group:
--                        generator.generate_for_group(persistent_group)
--                    generator.generate_loader(config)
--                    print("Regenerated shell files")
--                except Exception as e:
--                    print(f"Warning: Failed to regenerate files: {e}")
--                    print("Run 'shtick generate' to update shell files")
--            else:
--                print(f"Failed to remove {args.type} '{item}'")
--        else:
--            # Multiple matches, ask for confirmation
--            print(f"Found {len(matches)} matches in persistent group:")
--            for i, item in enumerate(matches, 1):
--                print(f"  {i}. {item}")
--
--            try:
--                choice = input("Enter number to remove (or 'q' to quit): ").strip()
--                if choice.lower() == "q":
--                    print("Cancelled")
--                    return
--
--                idx = int(choice) - 1
--                if 0 <= idx < len(matches):
--                    item = matches[idx]
--                    if config.remove_item(args.type, "persistent", item):
--                        config.save()
--                        print(f"Removed {args.type} '{item}' from persistent group")
--
--                        # Auto-regenerate files
--                        try:
--                            generator = Generator()
--                            persistent_group = config.get_persistent_group()
--                            if persistent_group:
--                                generator.generate_for_group(persistent_group)
--                            generator.generate_loader(config)
--                            print("Regenerated shell files")
--                        except Exception as e:
--                            print(f"Warning: Failed to regenerate files: {e}")
--                            print("Run 'shtick generate' to update shell files")
--                    else:
--                        print(f"Failed to remove {args.type} '{item}'")
--                else:
--                    print("Invalid choice")
--            except (ValueError, KeyboardInterrupt):
--                print("\nCancelled")
--
--    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 cmd_activate(args) -> None:
--    """Activate a group"""
--    config_path = Config.get_default_config_path()
--
--    try:
--        config = Config(config_path, debug=getattr(args, "debug", False))
--        config.load()
--
--        if args.group == "persistent":
--            print(
--                "Error: 'persistent' group is always active and cannot be manually activated"
--            )
--            return
--
--        if config.activate_group(args.group):
--            # Regenerate all files to ensure they exist and are up to date
--            from shtick.generator import Generator
--
--            generator = Generator()
--            # Generate shell files for all groups (not just the activated one)
--            for group in config.groups:
--                generator.generate_for_group(group)
--            # Then regenerate the loader to include newly activated group
--            generator.generate_loader(config)
--
--            print(f"Activated group '{args.group}'")
--            print("Changes are now active in new shell sessions")
--        else:
--            print(f"Error: Group '{args.group}' 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)
--
--
--def cmd_deactivate(args) -> None:
--    """Deactivate a group"""
--    config_path = Config.get_default_config_path()
--
--    try:
--        config = Config(config_path, debug=getattr(args, "debug", False))
--        config.load()
--
--        if args.group == "persistent":
--            print("Error: 'persistent' group cannot be deactivated")
--            return
--
--        if config.deactivate_group(args.group):
--            # Regenerate loader to exclude deactivated group
--            from shtick.generator import Generator
--
--            generator = Generator()
--            # Regenerate loader (no need to regenerate all files for deactivation)
--            generator.generate_loader(config)
--
--            print(f"Deactivated group '{args.group}'")
--            print("Changes will take effect in new shell sessions")
--        else:
--            print(f"Group '{args.group}' was not active")
--
--    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 cmd_list(args) -> None:
--    """List current configuration"""
--    config_path = Config.get_default_config_path()
--
--    try:
--        config = Config(config_path, debug=getattr(args, "debug", False))
--        config.load()
--
--        if not config.groups:
--            print("No groups configured")
--            return
--
--        persistent_group = config.get_persistent_group()
--        regular_groups = config.get_regular_groups()
--        active_groups = config.load_active_groups()
--
--        if args.long:
--            # Long format - detailed line-by-line
--            _print_detailed_list(persistent_group, regular_groups, active_groups)
--        else:
--            # Default tabular format
--            _print_tabular_list(persistent_group, regular_groups, active_groups)
--
--    except FileNotFoundError:
--        print(f"Config file not found: {config_path}")
--        print(
--            "Use 'shtick add' to create entries or 'shtick generate' with a config file"
--        )
--    except Exception as e:
--        print(f"Error: {e}")
--        sys.exit(1)
--
--
--def _print_detailed_list(persistent_group, regular_groups, active_groups) -> None:
--    """Print detailed line-by-line list format"""
--    # Show persistent group first
--    if persistent_group:
--        print("Group: persistent (always active)")
--        if persistent_group.aliases:
--            print(f"  Aliases ({len(persistent_group.aliases)}):")
--            for key, value in persistent_group.aliases.items():
--                print(f"    {key} = {value}")
--        if persistent_group.env_vars:
--            print(f"  Environment Variables ({len(persistent_group.env_vars)}):")
--            for key, value in persistent_group.env_vars.items():
--                print(f"    {key} = {value}")
--        if persistent_group.functions:
--            print(f"  Functions ({len(persistent_group.functions)}):")
--            for key, value in persistent_group.functions.items():
--                print(f"    {key} = {value}")
--        print()
--
--    # Show regular groups
--    for group in regular_groups:
--        status = " (ACTIVE)" if group.name in active_groups else " (inactive)"
--        print(f"Group: {group.name}{status}")
--
--        if group.aliases:
--            print(f"  Aliases ({len(group.aliases)}):")
--            for key, value in group.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():
--                print(f"    {key} = {value}")
--
--        if group.functions:
--            print(f"  Functions ({len(group.functions)}):")
--            for key, value in group.functions.items():
--                print(f"    {key} = {value}")
--        print()
--
--
--def _print_tabular_list(persistent_group, regular_groups, active_groups) -> None:
--    """Print compact tabular list format"""
--    # Collect all items for tabular display
--    items = []
--
--    # Add persistent items
--    if persistent_group:
--        for key, value in persistent_group.aliases.items():
--            items.append(("persistent", "alias", key, value, "PERSISTENT"))
--        for key, value in persistent_group.env_vars.items():
--            items.append(("persistent", "env", key, value, "PERSISTENT"))
--        for key, value in persistent_group.functions.items():
--            items.append(("persistent", "function", key, value, "PERSISTENT"))
--
--    # Add regular group items
--    for group in regular_groups:
--        status = "ACTIVE" if group.name in active_groups else "inactive"
--
--        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))
--
--    if not items:
--        print("No items configured")
--        return
--
--    # Calculate column widths
--    max_group = max(len(item[0]) for item in items)
--    max_type = max(len(item[1]) for item in items)
--    max_key = max(len(item[2]) for item in items)
--    max_value = max(min(len(item[3]), 50) for item in items)  # Limit value column width
--    max_status = max(len(item[4]) for item in items)
--
--    # Ensure minimum widths
--    max_group = max(max_group, 5)  # "Group"
--    max_type = max(max_type, 4)  # "Type"
--    max_key = max(max_key, 3)  # "Key"
--    max_value = max(max_value, 5)  # "Value"
--    max_status = max(max_status, 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))
--
--    # Print items
--    for group, item_type, key, value, status in items:
--        # Truncate long values with ellipsis
--        display_value = (
--            value if len(value) <= max_value else value[: max_value - 3] + "..."
--        )
--
--        print(
--            f"{group:<{max_group}} {item_type:<{max_type}} {key:<{max_key}} {display_value:<{max_value}} {status:<{max_status}}"
--        )
--
--    # Print summary
--    print()
--    total_items = len(items)
--    active_items = len([item for item in items if item[4] in ["ACTIVE", "PERSISTENT"]])
--    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")
--        print(f"Activate groups with: shtick activate <group>")
--        print(f"Inactive groups: {', '.join(sorted(inactive_groups))}")
--
--
--def cmd_shells(args) -> None:
--    """List supported shells"""
--    shells = sorted(get_supported_shells())
--
--    if args.long:
--        # Long format - one per line with descriptions
--        print("Supported shells:")
--        for shell in shells:
--            print(f"  {shell}")
--    else:
--        # Default columnar format (like ls)
--        _print_shells_columns(shells)
--
--
--def _print_shells_columns(shells) -> None:
--    """Print shells in columns like ls output"""
--    if not shells:
--        print("No shells configured")
--        return
--
--    # Try to get terminal width, fallback to 80
--    try:
--        import shutil
--
--        terminal_width = shutil.get_terminal_size().columns
--    except:
--        terminal_width = 80
--
--    # Find the longest shell name
--    max_shell_length = max(len(shell) for shell in shells)
--
--    # Add some padding
--    column_width = max_shell_length + 2
--
--    # Calculate how many columns we can fit
--    columns = max(1, terminal_width // column_width)
--
--    # Calculate number of rows needed
--    rows = (len(shells) + columns - 1) // columns
--
--    print(f"Supported shells ({len(shells)} total):")
--    print()
--
--    # Print shells in columns
--    for row in range(rows):
--        line = ""
--        for col in range(columns):
--            index = row + col * rows
--            if index < len(shells):
--                shell = shells[index]
--                line += f"{shell:<{column_width}}"
--        print(line.rstrip())
--
--
--def cmd_status(args) -> None:
--    """Show status of groups and active state"""
--    config_path = Config.get_default_config_path()
--
--    try:
--        config = Config(config_path, debug=getattr(args, "debug", False))
--        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 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")
--        else:
--            print("Persistent: No items")
--
--        print()
--
--        # 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()
--
--        # Show summary
--        if active_groups:
--            print(f"Currently active: {', '.join(active_groups)}")
--        else:
--            print("No groups currently active")
--
--        print()
--        print("To activate a group: shtick activate <group>")
--        print("To deactivate a group: shtick deactivate <group>")
--        print("To add persistent items: shtick add-persistent <type> <key>=<value>")
--
--    except FileNotFoundError:
--        print(f"Config file not found: {config_path}")
--        print("No configuration exists yet")
--    except Exception as e:
--        print(f"Error: {e}")
--        sys.exit(1)
  def main():
          "assignment", help="Assignment in format key=value"
+     )
++    # Shorthand commands for common operations
++    alias_parser = subparsers.add_parser(
++        "alias", help="Add persistent alias (shorthand for 'add-persistent alias')"
++    )
++    alias_parser.add_argument("assignment", help="Assignment in format key=value")
++
++    env_parser = subparsers.add_parser(
++        "env",
++        help="Add persistent environment variable (shorthand for 'add-persistent env')",
++    )
++    env_parser.add_argument("assignment", help="Assignment in format key=value")
++
++    function_parser = subparsers.add_parser(
++        "function",
++        help="Add persistent function (shorthand for 'add-persistent function')",
++    )
++    function_parser.add_argument("assignment", help="Assignment in format key=value")
++
      # Remove command
      rm_parser = subparsers.add_parser("remove", help="Remove an item from config")
      rm_parser.add_argument(
          help="Show one shell per line instead of columns",
+     )
++    # Source command (for eval)
++    source_parser = subparsers.add_parser(
++        "source", help="Output source command for eval (for immediate loading)"
++    )
++    source_parser.add_argument(
++        "--shell", help="Specify shell type (auto-detected if not provided)"
++    )
++
      args = parser.parse_args()
      if not args.command:
++        # Show helpful getting started message
          parser.print_help()
++        print("\nQuick start:")
++        print("  shtick alias ll='ls -la'      # Add a persistent alias")
++        print("  shtick status                 # Show current configuration")
++        print("  shtick list                   # List all items")
          sys.exit(1)
++    # Initialize command handlers
++    commands = ShtickCommands(debug=args.debug)
++    display = DisplayCommands(debug=args.debug)
++
++    # Route commands
      if args.command == "generate":
--        cmd_generate(args)
++        commands.generate(args.config, args.terse)
      elif args.command == "add":
--        cmd_add(args)
++        commands.add_item(args.type, args.group, args.assignment)
      elif args.command == "add-persistent":
--        cmd_add_persistent(args)
++        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":
--        cmd_remove(args)
++        commands.remove_item(args.type, args.group, args.search)
      elif args.command == "remove-persistent":
--        cmd_remove_persistent(args)
++        commands.remove_item(args.type, "persistent", args.search)
      elif args.command == "activate":
--        cmd_activate(args)
++        commands.activate_group(args.group)
      elif args.command == "deactivate":
--        cmd_deactivate(args)
++        commands.deactivate_group(args.group)
      elif args.command == "status":
--        cmd_status(args)
++        display.status()
      elif args.command == "list":
--        cmd_list(args)
++        display.list_config(args.long)
      elif args.command == "shells":
--        cmd_shells(args)
++        display.shells(args.long)
++    elif args.command == "source":
++        commands.source_command(args.shell)
  if __name__ == "__main__":

src/shtick/commands.pyadded

++"""
++Command implementations for shtick CLI
++"""
++
++import os
++import sys
++import subprocess
++from typing import Optional, List
++
++from shtick.config import Config
++from shtick.generator import Generator
++from shtick.shells import get_supported_shells
++
++
++class ShtickCommands:
++    """Central command handler for shtick operations"""
++
++    def __init__(self, debug: bool = False):
++        self.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
++
++    def validate_assignment(self, assignment: str) -> tuple[str, str]:
++        """Validate key=value assignment format and return key, value"""
++        if "=" not in assignment:
++            raise ValueError("Assignment must be in format key=value")
++
++        key, value = assignment.split("=", 1)
++        key = key.strip()
++        value = value.strip()
++
++        if not key or not value:
++            raise ValueError("Both key and value must be non-empty")
++
++        # Validate key format (basic shell identifier rules)
++        if not key.replace("_", "").replace("-", "").isalnum():
++            raise ValueError(
++                "Key must contain only letters, numbers, underscores, and hyphens"
++            )
++
++        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()
++        if not current_shell or current_shell not in ["bash", "zsh", "fish"]:
++            return
++
++        loader_path = os.path.expanduser(
++            f"~/.config/shtick/load_active.{current_shell}"
++        )
++        if not os.path.exists(loader_path):
++            print("Loader file not found. Run 'shtick generate' first.")
++            return
++
++        try:
++            response = (
++                input(f"\nSource shtick in current {current_shell} session? [Y/n]: ")
++                .strip()
++                .lower()
++            )
++            if response in ["", "y", "yes"]:
++                # Test syntax first
++                if self._test_loader_syntax(current_shell, loader_path):
++                    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:")
++        if shell == "fish":
++            print(f"eval (shtick source)")
++        else:
++            print(f'eval "$(shtick source)"')
++
++        print(f"\nOr run directly:")
++        print(f"source ~/.config/shtick/load_active.{shell}")
++
++        print("\n✨ Changes will be available in new shell sessions automatically.")
++        self._show_eval_hint(shell)
++
++    def _show_eval_hint(self, shell: str):
++        """Show eval hint for easier future use"""
++        print(f"\n💡 To automatically source shtick when making changes, use:")
++        print(f'eval "$(shtick source)"')
++        print(f"\nOr add this alias to your shell config:")
++        if shell in ["bash", "zsh"]:
++            print(f"alias ss='eval \"$(shtick source)\"'")
++        elif shell == "fish":
++            print(f"alias ss 'eval (shtick source)'")
++        print(f"Then just run 'ss' after adding aliases!")
++
++    def check_shell_integration(self):
++        """Check if shtick is properly integrated with shell config"""
++        current_shell = self.get_current_shell()
++        if not current_shell:
++            return
++
++        shell_configs = {
++            "bash": ["~/.bashrc", "~/.bash_profile"],
++            "zsh": ["~/.zshrc", "~/.zprofile"],
++            "fish": ["~/.config/fish/config.fish"],
++        }
++
++        if current_shell not in shell_configs:
++            return
++
++        loader_line = f"source ~/.config/shtick/load_active.{current_shell}"
++
++        # Check if already integrated
++        for config_file in shell_configs[current_shell]:
++            expanded_path = os.path.expanduser(config_file)
++            if os.path.exists(expanded_path):
++                try:
++                    with open(expanded_path, "r") as f:
++                        content = f.read()
++                        if "shtick" in content or loader_line in content:
++                            return  # Already integrated
++                except:
++                    continue
++
++        # Not integrated, offer to add
++        try:
++            print(
++                f"\n🔧 Shtick is not integrated with your {current_shell} configuration."
++            )
++            print("This means your aliases won't be available in new shell sessions.")
++            response = (
++                input("Add shtick to your shell config automatically? [Y/n]: ")
++                .strip()
++                .lower()
++            )
++            if response in ["", "y", "yes"]:
++                if self._add_shell_integration(
++                    current_shell, shell_configs[current_shell]
++                ):
++                    print(
++                        "\n✓ Integration complete! Your aliases will be available in new shell sessions."
++                    )
++                    print("To use them immediately in this session, run:")
++                    print(f"  source ~/.config/shtick/load_active.{current_shell}")
++            else:
++                print(
++                    f"\nTo manually integrate later, add this line to your {current_shell} config:"
++                )
++                print(f"  {loader_line}")
++        except (KeyboardInterrupt, EOFError):
++            print()
++
++    def _add_shell_integration(self, shell: str, config_files: List[str]) -> bool:
++        """Add shtick integration to shell config"""
++        loader_line = f"source ~/.config/shtick/load_active.{shell}"
++
++        # Try to find the best config file to modify
++        for config_file in config_files:
++            expanded_path = os.path.expanduser(config_file)
++            if os.path.exists(expanded_path):
++                try:
++                    with open(expanded_path, "a") as f:
++                        f.write(f"\n# Shtick shell configuration manager\n")
++                        f.write(f"{loader_line}\n")
++                    print(f"✓ Added shtick integration to {config_file}")
++                    return True
++                except Exception as e:
++                    print(f"✗ Failed to modify {config_file}: {e}")
++                    continue
++
++        # If no existing config file found, create the primary one
++        primary_config = config_files[0]
++        expanded_path = os.path.expanduser(primary_config)
++        try:
++            os.makedirs(os.path.dirname(expanded_path), exist_ok=True)
++            with open(expanded_path, "w") as f:
++                f.write(f"# Shtick shell configuration manager\n")
++                f.write(f"{loader_line}\n")
++            print(f"✓ Created {primary_config} with shtick integration")
++            return True
++        except Exception as e:
++            print(f"✗ Failed to create {primary_config}: {e}")
++            return False
++
++    # Command implementations
++    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 not terse:
++                self.check_shell_integration()
++
++        except FileNotFoundError as e:
++            print(f"Error: {e}")
++            print(f"Create a config file at {config_path} first")
++            sys.exit(1)
++        except Exception as e:
++            print(f"Error: {e}")
++            sys.exit(1)
++
++    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)
++
++        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()
++
++            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}")
++            sys.exit(1)
++
++    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)
++
++        config_path = Config.get_default_config_path()
++        is_first_time = not os.path.exists(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()
++
++            print(
++                f"✓ Added {item_type} '{key}' = '{value}' to persistent group (always active)"
++            )
++
++            # Auto-regenerate files
++            self.regenerate_and_offer_source(config, "persistent")
++
++            # 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}")
++            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)
++
++            if not matches:
++                print(
++                    f"No {item_type} items matching '{search}' found in group '{group}'"
++                )
++                return
++
++            # Handle single vs multiple matches
++            item_to_remove = self._select_item_to_remove(matches)
++            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}'")
++
++                # Auto-regenerate if group is active
++                if config.is_group_active(group) or group == "persistent":
++                    self.regenerate_and_offer_source(config, group)
++            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 _select_item_to_remove(self, matches: List[str]) -> Optional[str]:
++        """Handle selection of item to remove from matches"""
++        if len(matches) == 1:
++            return matches[0]
++
++        # Multiple matches, ask for confirmation
++        print(f"Found {len(matches)} matches:")
++        for i, item in enumerate(matches, 1):
++            print(f"  {i}. {item}")
++
++        try:
++            choice = input("Enter number to remove (or 'q' to quit): ").strip()
++            if choice.lower() == "q":
++                print("Cancelled")
++                return None
++
++            idx = int(choice) - 1
++            if 0 <= idx < len(matches):
++                return matches[idx]
++            else:
++                print("Invalid choice")
++                return None
++        except (ValueError, KeyboardInterrupt):
++            print("\nCancelled")
++            return None
++
++    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 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)
++
++    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")
++
++        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 source_command(self, shell: str = None):
++        """Output source command for eval"""
++        current_shell = shell or self.get_current_shell()
++
++        if not current_shell:
++            print("Could not detect shell. Use --shell to specify.", file=sys.stderr)
++            sys.exit(1)
++
++        loader_path = os.path.expanduser(
++            f"~/.config/shtick/load_active.{current_shell}"
++        )
++        if not os.path.exists(loader_path):
++            print(f"Loader file not found: {loader_path}", file=sys.stderr)
++            print("Run 'shtick generate' first.", file=sys.stderr)
++            sys.exit(1)
++
++        # Output the source command that can be eval'd
++        print(f"source {loader_path}")

src/shtick/display.pyadded

++"""
++Display commands for shtick CLI - handles listing, status, and informational output
++"""
++
++import os
++import sys
++from shtick.config import Config
++from shtick.shells import get_supported_shells
++
++
++class DisplayCommands:
++    """Handles all display/listing commands for shtick"""
++
++    def __init__(self, debug: bool = False):
++        self.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
++
++    def status(self):
++        """Show status of groups and active state"""
++        config_path = Config.get_default_config_path()
++
++        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()
++
++            # 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")
++            else:
++                print("Persistent: No items")
++
++            print()
++
++            # 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()
++
++            # Show summary
++            if active_groups:
++                print(f"Currently active: {', '.join(active_groups)}")
++            else:
++                print("No groups currently active")
++
++            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')
++
++        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)
++
++    def list_config(self, long_format: bool = False):
++        """List current configuration"""
++        config_path = Config.get_default_config_path()
++
++        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):
++        """Print detailed line-by-line list format"""
++        # Show persistent group first
++        if persistent_group:
++            print("Group: persistent (always active)")
++            self._print_group_items(persistent_group)
++            print()
++
++        # 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)
++            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():
++                print(f"    {key} = {value}")
++        if group.env_vars:
++            print(f"  Environment Variables ({len(group.env_vars)}):")
++            for key, value in group.env_vars.items():
++                print(f"    {key} = {value}")
++        if group.functions:
++            print(f"  Functions ({len(group.functions)}):")
++            for key, value in group.functions.items():
++                print(f"    {key} = {value}")
++
++    def _print_tabular_list(self, persistent_group, regular_groups, active_groups):
++        """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_value = max(
++            max(min(len(item[3]), 50) for item in items), 5
++        )  # "Value" (limited)
++        max_status = max(max(len(item[4]) 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))
++
++        # Print items
++        for group, item_type, key, value, status in items:
++            # Truncate long values with ellipsis
++            display_value = (
++                value if len(value) <= max_value else value[: max_value - 3] + "..."
++            )
++            print(
++                f"{group:<{max_group}} {item_type:<{max_type}} {key:<{max_key}} {display_value:<{max_value}} {status:<{max_status}}"
++            )
++
++    def _print_summary(self, items, active_groups):
++        """Print summary information"""
++        print()
++        total_items = len(items)
++        active_items = len(
++            [item for item in items if item[4] in ["ACTIVE", "PERSISTENT"]]
++        )
++        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")
++            print(f"Activate groups with: shtick activate <group>")
++            print(f"Inactive groups: {', '.join(sorted(inactive_groups))}")
++
++    def shells(self, long_format: bool = False):
++        """List supported shells"""
++        shells = sorted(get_supported_shells())
++
++        if long_format:
++            print("Supported shells:")
++            for shell in shells:
++                print(f"  {shell}")
++        else:
++            self._print_shells_columns(shells)
++
++    def _print_shells_columns(self, shells):
++        """Print shells in columns like ls output"""
++        if not shells:
++            print("No shells configured")
++            return
++
++        # Try to get terminal width, fallback to 80
++        try:
++            import shutil
++
++            terminal_width = shutil.get_terminal_size().columns
++        except:
++            terminal_width = 80
++
++        # Find the longest shell name
++        max_shell_length = max(len(shell) for shell in shells)
++        column_width = max_shell_length + 2
++
++        # Calculate how many columns we can fit
++        columns = max(1, terminal_width // column_width)
++        rows = (len(shells) + columns - 1) // columns
++
++        print(f"Supported shells ({len(shells)} total):")
++        print()
++
++        # Print shells in columns
++        for row in range(rows):
++            line = ""
++            for col in range(columns):
++                index = row + col * rows
++                if index < len(shells):
++                    shell = shells[index]
++                    line += f"{shell:<{column_width}}"
++            print(line.rstrip())