tenseleyflow/shtick / ec1f957

 import os

 from typing import Optional

 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.load()

         generator = Generator()

     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"""

         print("Error: Assignment must be in format key=value")

         sys.exit(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:

         # 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.load()

         # Find matching items

         matches = config.find_items(args.type, args.group, args.search)

         if not matches:

             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()

                     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.load()

             return

         if config.activate_group(args.group):

             from shtick.generator import Generator

             generator = Generator()

             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.load()

             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()

             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.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}")

     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_value = max(max_value, 5)  # "Value"

     # 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

     # 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.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:

             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"

                 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"

     )

     # Generate command

     # Remove command

     # Activate command

     # Status command

     # List command

     # Shells command

     args = parser.parse_args()

     if not args.command:

         parser.print_help()

         sys.exit(1)

         cmd_generate(args)

         cmd_add(args)

         cmd_remove(args)

         cmd_activate(args)

         cmd_deactivate(args)

         cmd_status(args)

         cmd_list(args)

         cmd_shells(args)

 class Config:

     """Main configuration handler"""

         self.config_path = config_path or self.get_default_config_path()

         self.groups: List[GroupData] = []

     @staticmethod

         if not os.path.exists(self.config_path):

             raise FileNotFoundError(f"Config file not found: {self.config_path}")

         with open(self.config_path, "rb") as f:

             data = tomllib.load(f)

         self.groups = []

         # Parse groups from nested TOML structure

         for group_name, group_config in data.items():

             if not isinstance(group_config, dict):

                 continue

             # Initialize group data

             # Extract each section from the group

             for section_name, section_data in group_config.items():

                 if section_name == "aliases" and isinstance(section_data, dict):

                     group_data["aliases"] = section_data

                 elif section_name == "env_vars" and isinstance(section_data, dict):

                     group_data["env_vars"] = section_data

                 elif section_name == "functions" and isinstance(section_data, dict):

                     group_data["functions"] = section_data

                 else:

             # Create GroupData object if group has any items

             total_items = (

                 + len(group_data["env_vars"])

                 + len(group_data["functions"])

             )

             if total_items > 0:

                 new_group = GroupData(

                     functions=group_data["functions"],

                 )

                 self.groups.append(new_group)

             else:

     def save(self) -> None:

         """Save the current configuration back to TOML file"""

                     f.write(line)

         """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}")

     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"]:

                     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"]:

                         f.write("\n")

                 else:

                     f.write("# No active groups\n")

         """Print usage instructions for the user"""

         active_groups = config.load_active_groups()

         persistent_group = config.get_persistent_group()

         if persistent_group:

             total_persistent = (

         if available_groups:

             print(f"Available groups: {', '.join(available_groups)}")

     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": []}