`ec1f957`

stable, interactive mode

Authored by

espadonne 11 months ago

SHA: ec1f957251882b1af459d5219023bf48eefcc628
Parents: b2cc963
Tree: 899fce8

3 changed files

Status	File	+	-
M	`src/shtick/cli.py`	196	138
M	`src/shtick/config.py`	45	27
M	`src/shtick/generator.py`	157	16

src/shtick/cli.pymodified

  import os
  from typing import Optional
--# Package imports
++# 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)
++        config = Config(config_path, debug=args.debug)
          config.load()
--
++
          generator = Generator()
--        generator.generate_all(config)
++        generator.generate_all(config, interactive=args.interactive)
--
++
      except FileNotFoundError as e:
          print(f"Error: {e}")
          print(f"Create a config file at {config_path} first")
          print(f"Error: {e}")
          sys.exit(1)
++
  def cmd_add(args) -> None:
      """Add an item to the config"""
--    if '=' not in args.assignment:
++    if "=" not in args.assignment:
          print("Error: Assignment must be in format key=value")
          sys.exit(1)
--
++
--    key, value = args.assignment.split('=', 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)
++        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_remove(args) -> None:
      """Remove an item from the config"""
      config_path = Config.get_default_config_path()
--
++
      try:
--        config = Config(config_path)
++        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}'")
++            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]
              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':
++                if choice.lower() == "q":
                      print("Cancelled")
                      return
--
++
                  idx = int(choice) - 1
                  if 0 <= idx < len(matches):
                      item = matches[idx]
                      print("Invalid choice")
              except (ValueError, KeyboardInterrupt):
                  print("\nCancelled")
--
++
      except FileNotFoundError:
          print(f"Config file not found: {config_path}")
          sys.exit(1)
          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)
++        config = Config(config_path, debug=getattr(args, "debug", False))
          config.load()
--
++
--        if args.group == 'persistent':
++        if args.group == "persistent":
--            print("Error: 'persistent' group is always active and cannot be manually activated")
++            print(
++                "Error: 'persistent' group is always active and cannot be manually activated"
++            )
              return
--
++
          if config.activate_group(args.group):
--            # Regenerate loader to include newly activated 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:
              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'")
          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)
++        config = Config(config_path, debug=getattr(args, "debug", False))
          config.load()
--
++
--        if args.group == 'persistent':
++        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)
          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)
++        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")
++        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
              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", "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_type = max(max_type, 4)  # "Type"
--    max_key = max(max_key, 3)      # "Key"
++    max_key = max(max_key, 3)  # "Key"
      max_value = max(max_value, 5)  # "Value"
--    max_status = max(max_status, 6) # "Status"
++    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] + "..."
++        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(
++            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")
          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:")
          # 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 = ""
                  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)
++        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)
++            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)
++                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>")
--
++
      except FileNotFoundError:
          print(f"Config file not found: {config_path}")
          print("No configuration exists yet")
          print(f"Error: {e}")
          sys.exit(1)
++
  def main():
      """Main CLI entry point"""
      parser = argparse.ArgumentParser(
          description="shtick - Generate shell configuration files from TOML"
+     )
--
++
--    subparsers = parser.add_subparsers(dest='command', help='Available commands')
++    # Global flags
--
++    parser.add_argument("--debug", action="store_true", help="Enable debug output")
++
++    subparsers = parser.add_subparsers(dest="command", help="Available commands")
++
      # Generate command
--    gen_parser = subparsers.add_parser('generate', help='Generate shell files from config')
++    gen_parser = subparsers.add_parser(
--    gen_parser.add_argument('config', nargs='?', help='Path to config TOML file')
++        "generate", help="Generate shell files from config"
--
++    )
--    # Add command
++    gen_parser.add_argument("config", nargs="?", help="Path to config TOML file")
--    add_parser = subparsers.add_parser('add', help='Add an item to config')
++    gen_parser.add_argument(
--    add_parser.add_argument('type', choices=['alias', 'env', 'function'],
++        "-i",
--                           help='Type of item to add')
++        "--interactive",
--    add_parser.add_argument('group', help='Group name')
++        action="store_true",
--    add_parser.add_argument('assignment', help='Assignment in format key=value')
++        help="Interactive shell selection for sourcing instructions",
--
++    )
++
++    # Add command
++    add_parser = subparsers.add_parser("add", help="Add an item to config")
++    add_parser.add_argument(
++        "type", choices=["alias", "env", "function"], help="Type of item to add"
++    )
++    add_parser.add_argument("group", help="Group name")
++    add_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 = subparsers.add_parser("remove", help="Remove an item from config")
--    rm_parser.add_argument('type', choices=['alias', 'env', 'function'],
++    rm_parser.add_argument(
--                          help='Type of item to remove')
++        "type", choices=["alias", "env", "function"], help="Type of item to remove"
--    rm_parser.add_argument('group', help='Group name')
++    )
--    rm_parser.add_argument('search', help='Search term (fuzzy match)')
++    rm_parser.add_argument("group", help="Group name")
--
++    rm_parser.add_argument("search", help="Search term (fuzzy match)")
++
      # Activate command
--    activate_parser = subparsers.add_parser('activate', help='Activate a group')
++    activate_parser = subparsers.add_parser("activate", help="Activate a group")
--    activate_parser.add_argument('group', help='Group name to activate')
++    activate_parser.add_argument("group", help="Group name to activate")
--
++
--    # Deactivate command
++    # Deactivate command
--    deactivate_parser = subparsers.add_parser('deactivate', help='Deactivate a group')
++    deactivate_parser = subparsers.add_parser("deactivate", help="Deactivate a group")
--    deactivate_parser.add_argument('group', help='Group name to deactivate')
++    deactivate_parser.add_argument("group", help="Group name to deactivate")
--
++
      # Status command
--    status_parser = subparsers.add_parser('status', help='Show status of groups')
++    status_parser = subparsers.add_parser("status", help="Show status of groups")
--
++
      # List command
--    list_parser = subparsers.add_parser('list', help='List current configuration')
++    list_parser = subparsers.add_parser("list", help="List current configuration")
--    list_parser.add_argument('-l', '--long', action='store_true',
++    list_parser.add_argument(
--                            help='Show detailed line-by-line format instead of table')
++        "-l",
--
++        "--long",
++        action="store_true",
++        help="Show detailed line-by-line format instead of table",
++    )
++
      # Shells command
--    shells_parser = subparsers.add_parser('shells', help='List supported shells')
++    shells_parser = subparsers.add_parser("shells", help="List supported shells")
--    shells_parser.add_argument('-l', '--long', action='store_true',
++    shells_parser.add_argument(
--                              help='Show one shell per line instead of columns')
++        "-l",
--
++        "--long",
++        action="store_true",
++        help="Show one shell per line instead of columns",
++    )
++
      args = parser.parse_args()
--
++
      if not args.command:
          parser.print_help()
          sys.exit(1)
--
++
--    if args.command == 'generate':
++    if args.command == "generate":
          cmd_generate(args)
--    elif args.command == 'add':
++    elif args.command == "add":
          cmd_add(args)
--    elif args.command == 'remove':
++    elif args.command == "remove":
          cmd_remove(args)
--    elif args.command == 'activate':
++    elif args.command == "activate":
          cmd_activate(args)
--    elif args.command == 'deactivate':
++    elif args.command == "deactivate":
          cmd_deactivate(args)
--    elif args.command == 'status':
++    elif args.command == "status":
          cmd_status(args)
--    elif args.command == 'list':
++    elif args.command == "list":
          cmd_list(args)
--    elif args.command == 'shells':
++    elif args.command == "shells":
          cmd_shells(args)
--if __name__ == '__main__':
++
--    main()
++if __name__ == "__main__":
++    main()

src/shtick/config.pymodified

  class Config:
      """Main configuration handler"""
--    def __init__(self, config_path: Optional[str] = None):
++    def __init__(self, config_path: Optional[str] = None, debug: bool = False):
          self.config_path = config_path or self.get_default_config_path()
++        self.debug = debug
          self.groups: List[GroupData] = []
      @staticmethod
          if not os.path.exists(self.config_path):
              raise FileNotFoundError(f"Config file not found: {self.config_path}")
--        print(f"Debug: Loading config from: {self.config_path}")
++        if self.debug:
++            print(f"Debug: Loading config from: {self.config_path}")
          with open(self.config_path, "rb") as f:
              data = tomllib.load(f)
--        print(f"Debug: Raw TOML data keys: {list(data.keys())}")
++        if self.debug:
--        print(f"Debug: Raw TOML data structure: {data}")
++            print(f"Debug: Raw TOML data keys: {list(data.keys())}")
++            print(f"Debug: Raw TOML data structure: {data}")
          self.groups = []
          # Parse groups from nested TOML structure
          for group_name, group_config in data.items():
--            print(f"Debug: Processing group '{group_name}' with config: {group_config}")
++            if self.debug:
++                print(
++                    f"Debug: Processing group '{group_name}' with config: {group_config}"
++                )
              if not isinstance(group_config, dict):
--                print(f"Debug: Skipping non-dict value for key '{group_name}'")
++                if self.debug:
++                    print(f"Debug: 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():
--                print(
++                if self.debug:
--                    f"Debug: Processing section '{section_name}' in group '{group_name}': {section_data}"
++                    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
--                    print(f"Debug: Added {len(section_data)} aliases to '{group_name}'")
++                    if self.debug:
++                        print(
++                            f"Debug: Added {len(section_data)} aliases to '{group_name}'"
++                        )
                  elif section_name == "env_vars" and isinstance(section_data, dict):
                      group_data["env_vars"] = section_data
--                    print(
++                    if self.debug:
--                        f"Debug: Added {len(section_data)} env_vars to '{group_name}'"
++                        print(
--                    )
++                            f"Debug: Added {len(section_data)} env_vars to '{group_name}'"
++                        )
                  elif section_name == "functions" and isinstance(section_data, dict):
                      group_data["functions"] = section_data
--                    print(
++                    if self.debug:
--                        f"Debug: Added {len(section_data)} functions to '{group_name}'"
++                        print(
--                    )
++                            f"Debug: Added {len(section_data)} functions to '{group_name}'"
++                        )
                  else:
--                    print(
++                    if self.debug:
--                        f"Debug: Unknown or invalid section '{section_name}' in group '{group_name}'"
++                        print(
--                    )
++                            f"Debug: Unknown or invalid section '{section_name}' in group '{group_name}'"
++                        )
              # Create GroupData object if group has any items
              total_items = (
                  + len(group_data["env_vars"])
                  + len(group_data["functions"])
+             )
--            print(f"Debug: Group '{group_name}' has {total_items} total items")
++            if self.debug:
++                print(f"Debug: Group '{group_name}' has {total_items} total items")
              if total_items > 0:
                  new_group = GroupData(
                      functions=group_data["functions"],
+                 )
                  self.groups.append(new_group)
--                print(
++                if self.debug:
--                    f"Debug: Created group '{group_name}' with {len(group_data['aliases'])} aliases, {len(group_data['env_vars'])} env_vars, {len(group_data['functions'])} functions"
++                    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"
++                    )
              else:
--                print(f"Warning: Group '{group_name}' has no items, skipping")
++                if self.debug:
++                    print(f"Warning: Group '{group_name}' has no items, skipping")
--        print(
++        if self.debug:
--            f"Debug: Final groups loaded: {[g.name for g in self.groups]} (total: {len(self.groups)})"
++            print(
--        )
++                f"Debug: 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"""

src/shtick/generator.pymodified

                      f.write(line)
--    def generate_all(self, config: Config) -> None:
++    def generate_all(self, config: Config, interactive: bool = False) -> None:
          """Generate shell files for all groups in config"""
          if not config.groups:
              print("No groups found in configuration")
          self.generate_loader(config)
          print(f"All done! Files generated in {self.output_base_dir}")
--        self._print_usage_instructions(config)
++        self._print_usage_instructions(config, interactive)
      def generate_loader(self, config: Config) -> None:
          """Generate dynamic loader files that source persistent + active groups"""
                  if persistent_group:
                      f.write("# Load persistent configuration\n")
                      for item_type in ["alias", "env", "function"]:
--                        file_path = f"$HOME/.config/shtick/persistent/{item_type}"
++                        # Map item_type to the actual filename prefix
--                        f.write(f'[ -f "{file_path}/{item_type}s.{shell_name}" ] && ')
++                        prefix_map = {
--                        f.write(f'source "{file_path}/{item_type}s.{shell_name}"\n')
++                            "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")
                  # Source active groups
                      for group_name in active_groups:
                          f.write(f"# Group: {group_name}\n")
                          for item_type in ["alias", "env", "function"]:
--                            file_path = f"$HOME/.config/shtick/{group_name}/{item_type}"
++                            # Map item_type to the actual filename prefix
--                            f.write(
++                            prefix_map = {
--                                f'[ -f "{file_path}/{item_type}s.{shell_name}" ] && '
++                                "alias": "aliases",
--                            )
++                                "env": "envvars",
--                            f.write(f'source "{file_path}/{item_type}s.{shell_name}"\n')
++                                "function": "functions",
++                            }
++                            prefix = prefix_map[item_type]
++                            file_path = f"$HOME/.config/shtick/{group_name}/{item_type}/{prefix}.{shell_name}"
++                            f.write(f'[ -f "{file_path}" ] && source "{file_path}"\n')
                          f.write("\n")
                  else:
                      f.write("# No active groups\n")
--    def _print_usage_instructions(self, config: Config) -> None:
++    def _print_usage_instructions(
++        self, config: Config, interactive: bool = False
++    ) -> None:
          """Print usage instructions for the user"""
          active_groups = config.load_active_groups()
          persistent_group = config.get_persistent_group()
--        print("\nTo use these configurations, add this line to your shell config:")
++        if interactive:
--        print("  # For bash/zsh (~/.bashrc or ~/.zshrc):")
++            self._interactive_shell_setup()
--        print("  source ~/.config/shtick/load_active.bash")
++        else:
--        print("\n  # For fish (~/.config/fish/config.fish):")
++            self._print_default_instructions()
--        print("  source ~/.config/shtick/load_active.fish")
          if persistent_group:
              total_persistent = (
          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, showing default instructions.")
++                self._print_default_instructions()
++                return
++
++            selected_shells = self._parse_shell_selection(user_input, shells)
++
++            if not selected_shells:
++                print("No valid shells selected, showing default instructions.")
++                self._print_default_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. Showing default instructions.")
++            self._print_default_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]]:
          """Get list of generated shell files for a group"""
          files = {"alias": [], "env": [], "function": []}