pomera-ai-commander 0.1.0

package/tools/generator_tools.py

@@ -0,0 +1,1217 @@
+"""
+Generator Tools Module for Promera AI Commander
+
+This module provides various text generation tools including:
+- Strong Password Generator
+- Repeating Text Generator
+- Lorem Ipsum Generator
+- UUID/GUID Generator
+
+Author: Promera AI Commander
+"""
+
+import tkinter as tk
+from tkinter import ttk
+import string
+import random
+import json
+import uuid
+import base64
+import hashlib
+
+
+class GeneratorTools:
+    """A class containing various text generation tools."""
+    
+    def __init__(self):
+        """Initialize the GeneratorTools class."""
+        self.tools = {
+            "Strong Password Generator": self.strong_password,
+            "Repeating Text Generator": self.repeating_text,
+            "Lorem Ipsum Generator": self.lorem_ipsum,
+            "UUID/GUID Generator": self.uuid_generator,
+            "Random Email Generator": self.random_email_generator
+        }
+    
+    def get_available_tools(self):
+        """Returns a list of available generator tools."""
+        return list(self.tools.keys())
+    
+    def get_default_settings(self):
+        """Returns default settings for all generator tools."""
+        return {
+            "Strong Password Generator": {"length": 20, "numbers": "", "symbols": "", "letters_percent": 70, "numbers_percent": 20, "symbols_percent": 10},
+            "Repeating Text Generator": {"times": 5, "separator": "+"},
+            "Lorem Ipsum Generator": {"count": 5, "type": "paragraphs", "format": "plain", "ordered": False},
+            "UUID/GUID Generator": {"version": 4, "format": "standard", "case": "lowercase", "count": 1, "namespace": "dns", "name": ""},
+            "Random Email Generator": {"count": 5, "separator_type": "list", "separator": ",", "domain_type": "random", "domain": "example.com"},
+            "ASCII Art Generator": {"font": "standard", "width": 80},
+            "Hash Generator": {"algorithms": ["md5", "sha256"], "uppercase": False},
+            "Slug Generator": {"separator": "-", "lowercase": True, "transliterate": True, "max_length": 0, "remove_stopwords": False}
+        }
+    
+    def process_text(self, input_text, tool_name, settings):
+        """Process text using the specified generator tool."""
+        if tool_name not in self.tools:
+            return f"Error: Unknown tool '{tool_name}'"
+        
+        return self.tools[tool_name](input_text, settings)
+    
+    @staticmethod
+    def strong_password(input_text, settings):
+        """Generates a strong, random password with specified character distribution."""
+        length = settings.get("length", 20)
+        numbers = settings.get("numbers", "")
+        symbols = settings.get("symbols", "")
+        letters_percent = settings.get("letters_percent", 70)
+        numbers_percent = settings.get("numbers_percent", 20)
+        symbols_percent = settings.get("symbols_percent", 10)
+        
+        if not isinstance(length, int) or length <= 0:
+            return "Error: Password length must be a positive number."
+        
+        # Validate percentages
+        total_percent = letters_percent + numbers_percent + symbols_percent
+        if total_percent != 100:
+            return "Error: Percentages must add up to 100%."
+        
+        # Character sets
+        letters = string.ascii_letters
+        digits = string.digits
+        special_chars = string.punctuation
+        
+        # Calculate character counts with ±5% approximation
+        def calculate_count(percent, total_length):
+            base_count = int((percent / 100) * total_length)
+            # Allow ±5% variation (rounded to nearest integer)
+            variation = max(1, int(0.05 * total_length))
+            min_count = max(0, base_count - variation)
+            max_count = min(total_length, base_count + variation)
+            return random.randint(min_count, max_count)
+        
+        letters_count = calculate_count(letters_percent, length)
+        numbers_count = calculate_count(numbers_percent, length)
+        symbols_count = length - letters_count - numbers_count
+        
+        # Ensure we don't exceed total length
+        if symbols_count < 0:
+            # Adjust if we went over
+            excess = abs(symbols_count)
+            if letters_count >= excess:
+                letters_count -= excess
+                symbols_count = 0
+            else:
+                numbers_count -= (excess - letters_count)
+                letters_count = 0
+                symbols_count = 0
+        
+        # Generate password parts
+        password_chars = []
+        
+        # Add letters
+        password_chars.extend(random.choices(letters, k=letters_count))
+        
+        # Add numbers
+        password_chars.extend(random.choices(digits, k=numbers_count))
+        
+        # Add symbols
+        password_chars.extend(random.choices(special_chars, k=symbols_count))
+        
+        # Ensure we have the exact length
+        while len(password_chars) < length:
+            password_chars.append(random.choice(letters + digits + special_chars))
+        
+        # Shuffle the password
+        random.shuffle(password_chars)
+        password = ''.join(password_chars)
+        
+        # Ensure included numbers and symbols are present
+        must_include = numbers + symbols
+        if must_include and len(must_include) <= length:
+            password_list = list(password)
+            for i, char in enumerate(must_include):
+                if i < len(password_list):
+                    password_list[i] = char
+            random.shuffle(password_list)
+            password = "".join(password_list)
+
+        return password
+    
+    @staticmethod
+    def repeating_text(input_text, settings):
+        """Repeats the input text a specified number of times."""
+        times = settings.get("times", 5)
+        separator = settings.get("separator", "+")
+        
+        if not isinstance(times, int) or times < 0:
+            return "Error: 'Times' must be a non-negative number."
+        return separator.join([input_text] * times)
+    
+    @staticmethod
+    def lorem_ipsum(input_text, settings):
+        """Generates Lorem Ipsum text in various formats."""
+        count = settings.get("count", 5)
+        text_type = settings.get("type", "paragraphs")
+        format_type = settings.get("format", "plain")
+        ordered = settings.get("ordered", False)
+        
+        # Validation
+        if not isinstance(count, int) or count <= 0:
+            return "Error: Count must be a positive integer."
+        
+        if format_type not in ['plain', 'html', 'markdown', 'json']:
+            return "Error: Format must be one of: 'plain', 'html', 'markdown', 'json'."
+        
+        # Lorem ipsum word bank
+        lorem_words = [
+            "lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing", "elit",
+            "sed", "do", "eiusmod", "tempor", "incididunt", "ut", "labore", "et", "dolore",
+            "magna", "aliqua", "enim", "ad", "minim", "veniam", "quis", "nostrud",
+            "exercitation", "ullamco", "laboris", "nisi", "aliquip", "ex", "ea", "commodo",
+            "consequat", "duis", "aute", "irure", "in", "reprehenderit", "voluptate",
+            "velit", "esse", "cillum", "fugiat", "nulla", "pariatur", "excepteur", "sint",
+            "occaecat", "cupidatat", "non", "proident", "sunt", "culpa", "qui", "officia",
+            "deserunt", "mollit", "anim", "id", "est", "laborum", "at", "vero", "eos",
+            "accusamus", "accusantium", "doloremque", "laudantium", "totam", "rem",
+            "aperiam", "eaque", "ipsa", "quae", "ab", "illo", "inventore", "veritatis"
+        ]
+        
+        def generate_sentence():
+            """Generate a single sentence."""
+            length = random.randint(8, 20)
+            words = random.choices(lorem_words, k=length)
+            words[0] = words[0].capitalize()
+            return " ".join(words) + "."
+        
+        def generate_paragraph():
+            """Generate a single paragraph."""
+            sentences = [generate_sentence() for _ in range(random.randint(3, 8))]
+            return " ".join(sentences)
+        
+        # Generate content based on type
+        if text_type == "words":
+            content = random.choices(lorem_words, k=count)
+        elif text_type == "sentences":
+            content = [generate_sentence() for _ in range(count)]
+        elif text_type == "paragraphs":
+            content = [generate_paragraph() for _ in range(count)]
+        elif text_type == "bytes":
+            # Generate text up to specified byte count
+            text = ""
+            while len(text.encode('utf-8')) < count:
+                text += generate_sentence() + " "
+            content = [text[:count]]
+        else:
+            return "Error: Invalid text type."
+        
+        # Format output
+        if format_type == "plain":
+            if text_type == "words":
+                return " ".join(content)
+            elif text_type == "sentences":
+                return " ".join(content)
+            elif text_type == "paragraphs":
+                return "\n\n".join(content)
+            else:  # bytes
+                return content[0]
+        
+        elif format_type == "html":
+            if text_type == "words":
+                return "<span>" + " ".join(content) + "</span>"
+            elif text_type == "sentences":
+                if ordered:
+                    items = "".join([f"<li>{sentence}</li>" for sentence in content])
+                    return f"<ol>{items}</ol>"
+                else:
+                    items = "".join([f"<li>{sentence}</li>" for sentence in content])
+                    return f"<ul>{items}</ul>"
+            elif text_type == "paragraphs":
+                paragraphs = "".join([f"<p>{para}</p>" for para in content])
+                return paragraphs
+            else:  # bytes
+                return f"<div>{content[0]}</div>"
+        
+        elif format_type == "markdown":
+            if text_type == "words":
+                return " ".join(content)
+            elif text_type == "sentences":
+                if ordered:
+                    items = "\n".join([f"{i+1}. {sentence}" for i, sentence in enumerate(content)])
+                else:
+                    items = "\n".join([f"- {sentence}" for sentence in content])
+                return items
+            elif text_type == "paragraphs":
+                return "\n\n".join(content)
+            else:  # bytes
+                return content[0]
+        
+        elif format_type == "json":
+            return json.dumps({
+                "type": text_type,
+                "count": len(content),
+                "content": content
+            }, indent=2)
+        
+        return "Error: Unknown format type."
+    
+    @staticmethod
+    def uuid_generator(input_text, settings):
+        """Generates UUID/GUID in various formats and versions."""
+        version = settings.get("version", 4)
+        format_type = settings.get("format", "standard")
+        case = settings.get("case", "lowercase")
+        count = settings.get("count", 1)
+        namespace_name = settings.get("namespace", "dns")
+        name = settings.get("name", "")
+        
+        # Validation
+        if not isinstance(count, int) or count <= 0:
+            return "Error: Count must be a positive integer."
+        
+        if version not in [1, 3, 4, 5]:
+            return "Error: UUID version must be 1, 3, 4, or 5."
+        
+        if version in [3, 5] and not name:
+            return "Error: Name is required for UUID versions 3 and 5."
+        
+        # Predefined namespaces
+        namespaces = {
+            "dns": uuid.NAMESPACE_DNS,
+            "url": uuid.NAMESPACE_URL,
+            "oid": uuid.NAMESPACE_OID,
+            "x500": uuid.NAMESPACE_X500
+        }
+        
+        def generate_single_uuid():
+            """Generate a single UUID based on version."""
+            if version == 1:
+                return uuid.uuid1()
+            elif version == 3:
+                if namespace_name not in namespaces:
+                    return None
+                return uuid.uuid3(namespaces[namespace_name], name)
+            elif version == 4:
+                return uuid.uuid4()
+            elif version == 5:
+                if namespace_name not in namespaces:
+                    return None
+                return uuid.uuid5(namespaces[namespace_name], name)
+        
+        def format_uuid(uuid_obj):
+            """Format UUID according to specified format and case."""
+            if uuid_obj is None:
+                return "Error: Invalid namespace."
+            
+            uuid_str = str(uuid_obj)
+            
+            # Apply case formatting
+            if case == "uppercase":
+                uuid_str = uuid_str.upper()
+            elif case == "lowercase":
+                uuid_str = uuid_str.lower()
+            
+            # Apply format
+            if format_type == "standard":
+                return uuid_str
+            elif format_type == "hex":
+                return uuid_str.replace("-", "")
+            elif format_type == "microsoft":
+                return "{" + uuid_str + "}"
+            elif format_type == "urn":
+                return "urn:uuid:" + uuid_str
+            elif format_type == "base64":
+                return base64.b64encode(uuid_obj.bytes).decode('ascii')
+            elif format_type == "c_array":
+                bytes_list = list(uuid_obj.bytes)
+                hex_values = [f"0x{b:02x}" for b in bytes_list]
+                # Format as C array with proper line breaks
+                formatted = "{ " + ", ".join(hex_values[:8]) + ",\n  " + ", ".join(hex_values[8:]) + " }"
+                return formatted
+            elif format_type == "nil":
+                return "00000000-0000-0000-0000-000000000000"
+            else:
+                return uuid_str
+        
+        # Generate UUIDs
+        results = []
+        for _ in range(count):
+            if format_type == "nil":
+                # Special case for nil UUID
+                nil_uuid = uuid.UUID('00000000-0000-0000-0000-000000000000')
+                results.append(format_uuid(nil_uuid))
+            else:
+                uuid_obj = generate_single_uuid()
+                if uuid_obj is None:
+                    return "Error: Invalid namespace for name-based UUID."
+                results.append(format_uuid(uuid_obj))
+        
+        # Return results
+        if count == 1:
+            return results[0]
+        else:
+            return "\n".join(results)
+    
+    @staticmethod
+    def random_email_generator(input_text, settings):
+        """Generates random email addresses."""
+        count = settings.get("count", 5)
+        separator_type = settings.get("separator_type", "list")
+        separator = settings.get("separator", ",")
+        domain_type = settings.get("domain_type", "random")
+        domain = settings.get("domain", "example.com")
+        
+        # Validation
+        if not isinstance(count, int) or count <= 0:
+            return "Error: Count must be a positive integer."
+        
+        # Common first names and last names for generating realistic emails
+        first_names = [
+            "john", "jane", "mike", "sarah", "david", "lisa", "chris", "anna", "james", "mary",
+            "robert", "jennifer", "michael", "linda", "william", "elizabeth", "richard", "barbara",
+            "joseph", "susan", "thomas", "jessica", "charles", "karen", "daniel", "nancy",
+            "matthew", "betty", "anthony", "helen", "mark", "sandra", "donald", "donna",
+            "steven", "carol", "paul", "ruth", "andrew", "sharon", "joshua", "michelle",
+            "kenneth", "laura", "kevin", "sarah", "brian", "kimberly", "george", "deborah",
+            "edward", "dorothy", "ronald", "lisa", "timothy", "nancy", "jason", "karen"
+        ]
+        
+        last_names = [
+            "smith", "johnson", "williams", "brown", "jones", "garcia", "miller", "davis",
+            "rodriguez", "martinez", "hernandez", "lopez", "gonzalez", "wilson", "anderson",
+            "thomas", "taylor", "moore", "jackson", "martin", "lee", "perez", "thompson",
+            "white", "harris", "sanchez", "clark", "ramirez", "lewis", "robinson", "walker",
+            "young", "allen", "king", "wright", "scott", "torres", "nguyen", "hill",
+            "flores", "green", "adams", "nelson", "baker", "hall", "rivera", "campbell",
+            "mitchell", "carter", "roberts", "gomez", "phillips", "evans", "turner", "diaz"
+        ]
+        
+        # Common domain names for random domain generation
+        random_domains = [
+            "gmail.com", "yahoo.com", "hotmail.com", "outlook.com", "aol.com",
+            "icloud.com", "protonmail.com", "mail.com", "zoho.com", "fastmail.com",
+            "example.com", "test.com", "demo.org", "sample.net", "placeholder.io"
+        ]
+        
+        def generate_single_email():
+            """Generate a single random email address."""
+            # Generate username part
+            first = random.choice(first_names)
+            last = random.choice(last_names)
+            
+            # Various username patterns
+            patterns = [
+                f"{first}.{last}",
+                f"{first}{last}",
+                f"{first}_{last}",
+                f"{first}{random.randint(1, 999)}",
+                f"{first}.{last}{random.randint(1, 99)}",
+                f"{first[0]}{last}",
+                f"{first}{last[0]}",
+                f"{first}.{last[0]}",
+                f"{first[0]}.{last}"
+            ]
+            
+            username = random.choice(patterns)
+            
+            # Generate domain part
+            if domain_type == "random":
+                email_domain = random.choice(random_domains)
+            else:
+                email_domain = domain
+            
+            return f"{username}@{email_domain}"
+        
+        # Generate emails
+        emails = []
+        for _ in range(count):
+            emails.append(generate_single_email())
+        
+        # Format output based on separator type
+        if separator_type == "list":
+            return "\n".join(emails)
+        else:
+            return separator.join(emails)
+
+
+class GeneratorToolsWidget:
+    """Widget for the Generator Tools tabbed interface."""
+    
+    def __init__(self, generator_tools):
+        """Initialize the GeneratorToolsWidget."""
+        self.generator_tools = generator_tools
+        self.main_app = None
+        
+        # Variables for Strong Password Generator
+        self.pw_len_var = None
+        self.pw_num_var = None
+        self.pw_sym_var = None
+        self.pw_letters_percent_var = None
+        self.pw_numbers_percent_var = None
+        self.pw_symbols_percent_var = None
+        
+        # Variables for Repeating Text Generator
+        self.repeat_times_var = None
+        self.repeat_sep_var = None
+        
+        # Variables for Lorem Ipsum Generator
+        self.lorem_count_var = None
+        self.lorem_type_var = None
+        self.lorem_format_var = None
+        self.lorem_ordered_var = None
+        
+        # Variables for UUID/GUID Generator
+        self.uuid_version_var = None
+        self.uuid_format_var = None
+        self.uuid_case_var = None
+        self.uuid_count_var = None
+        self.uuid_namespace_var = None
+        self.uuid_name_var = None
+        
+        # Variables for Random Email Generator
+        self.email_count_var = None
+        self.email_separator_type_var = None
+        self.email_separator_var = None
+        self.email_domain_type_var = None
+        self.email_domain_var = None
+    
+    def create_widget(self, parent, main_app):
+        """Create and return the main widget."""
+        self.main_app = main_app
+        
+        # Create main frame
+        main_frame = ttk.Frame(parent)
+        
+        # Create notebook for tabs
+        self.notebook = ttk.Notebook(main_frame)
+        self.notebook.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
+        
+        # Create tabs
+        self.create_password_generator_tab()
+        self.create_repeating_text_tab()
+        self.create_lorem_ipsum_tab()
+        self.create_uuid_generator_tab()
+        self.create_email_generator_tab()
+        self.create_ascii_art_generator_tab()
+        self.create_hash_generator_tab()
+        self.create_slug_generator_tab()
+        
+        return main_frame
+    
+    def create_password_generator_tab(self):
+        """Create the Strong Password Generator tab."""
+        tab_frame = ttk.Frame(self.notebook)
+        self.notebook.add(tab_frame, text="Strong Password Generator")
+        
+        # Get current settings
+        settings = self.main_app.settings["tool_settings"].get("Generator Tools", {}).get("Strong Password Generator", {})
+        
+        # Length setting
+        length_frame = ttk.Frame(tab_frame)
+        length_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        ttk.Label(length_frame, text="Password Length:").pack(side=tk.LEFT)
+        self.pw_len_var = tk.StringVar(value=str(settings.get("length", 20)))
+        length_entry = ttk.Entry(length_frame, textvariable=self.pw_len_var, width=10)
+        length_entry.pack(side=tk.LEFT, padx=(5, 0))
+        
+        # Character distribution sliders
+        distribution_frame = ttk.LabelFrame(tab_frame, text="Character Distribution (%)")
+        distribution_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        # Letters percentage slider
+        letters_frame = ttk.Frame(distribution_frame)
+        letters_frame.pack(fill=tk.X, padx=5, pady=2)
+        
+        ttk.Label(letters_frame, text="Letters:", width=12).pack(side=tk.LEFT)
+        self.pw_letters_percent_var = tk.IntVar(value=settings.get("letters_percent", 70))
+        letters_slider = ttk.Scale(letters_frame, from_=0, to=100, orient=tk.HORIZONTAL, 
+                                 variable=self.pw_letters_percent_var, command=self.update_percentages)
+        letters_slider.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=(5, 5))
+        letters_label = ttk.Label(letters_frame, text="70%", width=5)
+        letters_label.pack(side=tk.RIGHT)
+        self.pw_letters_label = letters_label
+        
+        # Numbers percentage slider
+        numbers_frame = ttk.Frame(distribution_frame)
+        numbers_frame.pack(fill=tk.X, padx=5, pady=2)
+        
+        ttk.Label(numbers_frame, text="Numbers:", width=12).pack(side=tk.LEFT)
+        self.pw_numbers_percent_var = tk.IntVar(value=settings.get("numbers_percent", 20))
+        numbers_slider = ttk.Scale(numbers_frame, from_=0, to=100, orient=tk.HORIZONTAL, 
+                                 variable=self.pw_numbers_percent_var, command=self.update_percentages)
+        numbers_slider.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=(5, 5))
+        numbers_label = ttk.Label(numbers_frame, text="20%", width=5)
+        numbers_label.pack(side=tk.RIGHT)
+        self.pw_numbers_label = numbers_label
+        
+        # Symbols percentage slider
+        symbols_frame = ttk.Frame(distribution_frame)
+        symbols_frame.pack(fill=tk.X, padx=5, pady=2)
+        
+        ttk.Label(symbols_frame, text="Symbols:", width=12).pack(side=tk.LEFT)
+        self.pw_symbols_percent_var = tk.IntVar(value=settings.get("symbols_percent", 10))
+        symbols_slider = ttk.Scale(symbols_frame, from_=0, to=100, orient=tk.HORIZONTAL, 
+                                 variable=self.pw_symbols_percent_var, command=self.update_percentages)
+        symbols_slider.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=(5, 5))
+        symbols_label = ttk.Label(symbols_frame, text="10%", width=5)
+        symbols_label.pack(side=tk.RIGHT)
+        self.pw_symbols_label = symbols_label
+        
+        # Total percentage display
+        total_frame = ttk.Frame(distribution_frame)
+        total_frame.pack(fill=tk.X, padx=5, pady=2)
+        
+        ttk.Label(total_frame, text="Total:", width=12, font=('TkDefaultFont', 9, 'bold')).pack(side=tk.LEFT)
+        self.pw_total_label = ttk.Label(total_frame, text="100%", width=5, font=('TkDefaultFont', 9, 'bold'))
+        self.pw_total_label.pack(side=tk.RIGHT)
+        
+        # Numbers setting
+        numbers_include_frame = ttk.Frame(tab_frame)
+        numbers_include_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        ttk.Label(numbers_include_frame, text="Must Include Numbers:").pack(side=tk.LEFT)
+        self.pw_num_var = tk.StringVar(value=settings.get("numbers", ""))
+        numbers_entry = ttk.Entry(numbers_include_frame, textvariable=self.pw_num_var, width=20)
+        numbers_entry.pack(side=tk.LEFT, padx=(5, 0))
+        
+        # Symbols setting
+        symbols_include_frame = ttk.Frame(tab_frame)
+        symbols_include_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        ttk.Label(symbols_include_frame, text="Must Include Symbols:").pack(side=tk.LEFT)
+        self.pw_sym_var = tk.StringVar(value=settings.get("symbols", ""))
+        symbols_entry = ttk.Entry(symbols_include_frame, textvariable=self.pw_sym_var, width=20)
+        symbols_entry.pack(side=tk.LEFT, padx=(5, 0))
+        
+        # Generate button
+        button_frame = ttk.Frame(tab_frame)
+        button_frame.pack(fill=tk.X, padx=10, pady=10)
+        
+        generate_btn = ttk.Button(button_frame, text="Generate Password", 
+                                command=lambda: self.generate_password())
+        generate_btn.pack(side=tk.LEFT)
+        
+        # Initialize percentage display
+        self.update_percentages()
+    
+    def create_repeating_text_tab(self):
+        """Create the Repeating Text Generator tab."""
+        tab_frame = ttk.Frame(self.notebook)
+        self.notebook.add(tab_frame, text="Repeating Text Generator")
+        
+        # Get current settings
+        settings = self.main_app.settings["tool_settings"].get("Generator Tools", {}).get("Repeating Text Generator", {})
+        
+        # Times setting
+        times_frame = ttk.Frame(tab_frame)
+        times_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        ttk.Label(times_frame, text="Repeat Times:").pack(side=tk.LEFT)
+        self.repeat_times_var = tk.StringVar(value=str(settings.get("times", 5)))
+        times_entry = ttk.Entry(times_frame, textvariable=self.repeat_times_var, width=10)
+        times_entry.pack(side=tk.LEFT, padx=(5, 0))
+        
+        # Separator setting
+        separator_frame = ttk.Frame(tab_frame)
+        separator_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        ttk.Label(separator_frame, text="Separator:").pack(side=tk.LEFT)
+        self.repeat_sep_var = tk.StringVar(value=settings.get("separator", "+"))
+        separator_entry = ttk.Entry(separator_frame, textvariable=self.repeat_sep_var, width=20)
+        separator_entry.pack(side=tk.LEFT, padx=(5, 0))
+        
+        # Generate button
+        button_frame = ttk.Frame(tab_frame)
+        button_frame.pack(fill=tk.X, padx=10, pady=10)
+        
+        repeat_btn = ttk.Button(button_frame, text="Generate Repeated Text", 
+                              command=lambda: self.generate_repeated_text())
+        repeat_btn.pack(side=tk.LEFT)
+    
+    def create_lorem_ipsum_tab(self):
+        """Create the Lorem Ipsum Generator tab."""
+        tab_frame = ttk.Frame(self.notebook)
+        self.notebook.add(tab_frame, text="Lorem Ipsum Generator")
+        
+        # Get current settings
+        settings = self.main_app.settings["tool_settings"].get("Generator Tools", {}).get("Lorem Ipsum Generator", {})
+        
+        # Count setting
+        count_frame = ttk.Frame(tab_frame)
+        count_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        ttk.Label(count_frame, text="Count:").pack(side=tk.LEFT)
+        self.lorem_count_var = tk.StringVar(value=str(settings.get("count", 5)))
+        count_entry = ttk.Entry(count_frame, textvariable=self.lorem_count_var, width=10)
+        count_entry.pack(side=tk.LEFT, padx=(5, 0))
+        
+        # Type selection (radio buttons)
+        type_frame = ttk.LabelFrame(tab_frame, text="Type")
+        type_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        self.lorem_type_var = tk.StringVar(value=settings.get("type", "paragraphs"))
+        
+        type_options = [
+            ("Words", "words"),
+            ("Sentences", "sentences"),
+            ("Paragraphs", "paragraphs"),
+            ("Bytes", "bytes")
+        ]
+        
+        for text, value in type_options:
+            ttk.Radiobutton(type_frame, text=text, variable=self.lorem_type_var, 
+                          value=value).pack(side=tk.LEFT, padx=5)
+        
+        # Format selection (radio buttons)
+        format_frame = ttk.LabelFrame(tab_frame, text="Format")
+        format_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        self.lorem_format_var = tk.StringVar(value=settings.get("format", "plain"))
+        
+        format_options = [
+            ("Plain", "plain"),
+            ("HTML", "html"),
+            ("Markdown", "markdown"),
+            ("JSON", "json")
+        ]
+        
+        for text, value in format_options:
+            ttk.Radiobutton(format_frame, text=text, variable=self.lorem_format_var, 
+                          value=value).pack(side=tk.LEFT, padx=5)
+        
+        # Ordered checkbox (for lists)
+        ordered_frame = ttk.Frame(tab_frame)
+        ordered_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        self.lorem_ordered_var = tk.BooleanVar(value=settings.get("ordered", False))
+        ordered_check = ttk.Checkbutton(ordered_frame, text="Ordered (for lists)", 
+                                      variable=self.lorem_ordered_var)
+        ordered_check.pack(side=tk.LEFT)
+        
+        # Generate button
+        button_frame = ttk.Frame(tab_frame)
+        button_frame.pack(fill=tk.X, padx=10, pady=10)
+        
+        lorem_btn = ttk.Button(button_frame, text="Generate", 
+                             command=lambda: self.generate_lorem_ipsum())
+        lorem_btn.pack(side=tk.LEFT)
+    
+    def create_uuid_generator_tab(self):
+        """Create the UUID/GUID Generator tab."""
+        tab_frame = ttk.Frame(self.notebook)
+        self.notebook.add(tab_frame, text="UUID/GUID Generator")
+        
+        # Get current settings
+        settings = self.main_app.settings["tool_settings"].get("Generator Tools", {}).get("UUID/GUID Generator", {})
+        
+        # Create top row frame for UUID Version and Name-based settings
+        top_row_frame = ttk.Frame(tab_frame)
+        top_row_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        # UUID Version selection (left side)
+        version_frame = ttk.LabelFrame(top_row_frame, text="UUID Version")
+        version_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(0, 5))
+        
+        self.uuid_version_var = tk.IntVar(value=settings.get("version", 4))
+        
+        version_options = [
+            ("Version 1 (Time-based)", 1),
+            ("Version 3 (MD5 Name-based)", 3),
+            ("Version 4 (Random)", 4),
+            ("Version 5 (SHA-1 Name-based)", 5)
+        ]
+        
+        for text, value in version_options:
+            ttk.Radiobutton(version_frame, text=text, variable=self.uuid_version_var, 
+                          value=value, command=self.update_uuid_fields).pack(anchor=tk.W, padx=5, pady=2)
+        
+        # Name-based UUID settings (right side, for versions 3 and 5)
+        self.uuid_namebased_frame = ttk.LabelFrame(top_row_frame, text="Name-based Settings")
+        self.uuid_namebased_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True, padx=(5, 0))
+        
+        # Namespace selection
+        namespace_frame = ttk.Frame(self.uuid_namebased_frame)
+        namespace_frame.pack(fill=tk.X, padx=5, pady=2)
+        
+        ttk.Label(namespace_frame, text="Namespace:").pack(side=tk.LEFT)
+        self.uuid_namespace_var = tk.StringVar(value=settings.get("namespace", "dns"))
+        namespace_combo = ttk.Combobox(namespace_frame, textvariable=self.uuid_namespace_var, 
+                                     values=["dns", "url", "oid", "x500"], state="readonly", width=15)
+        namespace_combo.pack(side=tk.LEFT, padx=(5, 0))
+        
+        # Name input
+        name_frame = ttk.Frame(self.uuid_namebased_frame)
+        name_frame.pack(fill=tk.X, padx=5, pady=2)
+        
+        ttk.Label(name_frame, text="Name:").pack(side=tk.LEFT)
+        self.uuid_name_var = tk.StringVar(value=settings.get("name", ""))
+        name_entry = ttk.Entry(name_frame, textvariable=self.uuid_name_var, width=25)
+        name_entry.pack(side=tk.LEFT, padx=(5, 0), fill=tk.X, expand=True)
+        
+        # Output Format selection
+        format_frame = ttk.LabelFrame(tab_frame, text="Output Format")
+        format_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        self.uuid_format_var = tk.StringVar(value=settings.get("format", "standard"))
+        
+        format_options = [
+            ("Standard (8-4-4-4-12)", "standard"),
+            ("Hex (32 chars)", "hex"),
+            ("Microsoft GUID {}", "microsoft"),
+            ("URN format", "urn"),
+            ("Base64", "base64"),
+            ("C Array", "c_array"),
+            ("Nil UUID", "nil")
+        ]
+        
+        # Create two columns for format options
+        format_left = ttk.Frame(format_frame)
+        format_left.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        format_right = ttk.Frame(format_frame)
+        format_right.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)
+        
+        for i, (text, value) in enumerate(format_options):
+            parent = format_left if i < 4 else format_right
+            ttk.Radiobutton(parent, text=text, variable=self.uuid_format_var, 
+                          value=value).pack(anchor=tk.W, padx=5, pady=1)
+        
+        # Case selection
+        case_frame = ttk.LabelFrame(tab_frame, text="Case")
+        case_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        self.uuid_case_var = tk.StringVar(value=settings.get("case", "lowercase"))
+        
+        case_options = [
+            ("Lowercase", "lowercase"),
+            ("Uppercase", "uppercase")
+        ]
+        
+        for text, value in case_options:
+            ttk.Radiobutton(case_frame, text=text, variable=self.uuid_case_var, 
+                          value=value).pack(side=tk.LEFT, padx=5)
+        
+        # Count setting
+        count_frame = ttk.Frame(tab_frame)
+        count_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        ttk.Label(count_frame, text="Count:").pack(side=tk.LEFT)
+        self.uuid_count_var = tk.StringVar(value=str(settings.get("count", 1)))
+        count_entry = ttk.Entry(count_frame, textvariable=self.uuid_count_var, width=10)
+        count_entry.pack(side=tk.LEFT, padx=(5, 0))
+        
+        # Generate button
+        button_frame = ttk.Frame(tab_frame)
+        button_frame.pack(fill=tk.X, padx=10, pady=10)
+        
+        uuid_btn = ttk.Button(button_frame, text="Generate", 
+                            command=lambda: self.generate_uuid())
+        uuid_btn.pack(side=tk.LEFT)
+        
+        # Initialize field visibility
+        self.update_uuid_fields()
+    
+    def create_email_generator_tab(self):
+        """Create the Random Email Generator tab."""
+        tab_frame = ttk.Frame(self.notebook)
+        self.notebook.add(tab_frame, text="Random Email Generator")
+        
+        # Get current settings
+        settings = self.main_app.settings["tool_settings"].get("Generator Tools", {}).get("Random Email Generator", {})
+        
+        # Count setting
+        count_frame = ttk.Frame(tab_frame)
+        count_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        ttk.Label(count_frame, text="Count:").pack(side=tk.LEFT)
+        self.email_count_var = tk.StringVar(value=str(settings.get("count", 5)))
+        count_entry = ttk.Entry(count_frame, textvariable=self.email_count_var, width=10)
+        count_entry.pack(side=tk.LEFT, padx=(5, 0))
+        
+        # Separator type selection (radio buttons)
+        separator_type_frame = ttk.LabelFrame(tab_frame, text="Output Format")
+        separator_type_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        self.email_separator_type_var = tk.StringVar(value=settings.get("separator_type", "list"))
+        
+        separator_type_options = [
+            ("List (\\n separator)", "list"),
+            ("Custom Separator", "custom")
+        ]
+        
+        for text, value in separator_type_options:
+            ttk.Radiobutton(separator_type_frame, text=text, variable=self.email_separator_type_var, 
+                          value=value, command=self.update_email_separator_field).pack(side=tk.LEFT, padx=5)
+        
+        # Custom separator field
+        self.email_separator_frame = ttk.Frame(tab_frame)
+        self.email_separator_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        ttk.Label(self.email_separator_frame, text="Separator:").pack(side=tk.LEFT)
+        self.email_separator_var = tk.StringVar(value=settings.get("separator", ","))
+        separator_entry = ttk.Entry(self.email_separator_frame, textvariable=self.email_separator_var, width=10)
+        separator_entry.pack(side=tk.LEFT, padx=(5, 0))
+        
+        # Domain type selection (radio buttons)
+        domain_type_frame = ttk.LabelFrame(tab_frame, text="Domain")
+        domain_type_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        self.email_domain_type_var = tk.StringVar(value=settings.get("domain_type", "random"))
+        
+        domain_type_options = [
+            ("Random", "random"),
+            ("Custom Domain", "custom")
+        ]
+        
+        for text, value in domain_type_options:
+            ttk.Radiobutton(domain_type_frame, text=text, variable=self.email_domain_type_var, 
+                          value=value, command=self.update_email_domain_field).pack(side=tk.LEFT, padx=5)
+        
+        # Custom domain field
+        self.email_domain_frame = ttk.Frame(tab_frame)
+        self.email_domain_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        ttk.Label(self.email_domain_frame, text="Domain:").pack(side=tk.LEFT)
+        self.email_domain_var = tk.StringVar(value=settings.get("domain", "example.com"))
+        domain_entry = ttk.Entry(self.email_domain_frame, textvariable=self.email_domain_var, width=30)
+        domain_entry.pack(side=tk.LEFT, padx=(5, 0))
+        
+        # Generate button
+        button_frame = ttk.Frame(tab_frame)
+        button_frame.pack(fill=tk.X, padx=10, pady=10)
+        
+        email_btn = ttk.Button(button_frame, text="Generate", 
+                             command=lambda: self.generate_emails())
+        email_btn.pack(side=tk.LEFT)
+        
+        # Initialize field visibility
+        self.update_email_separator_field()
+        self.update_email_domain_field()
+    
+    def update_uuid_fields(self):
+        """Update UUID field visibility based on selected version."""
+        if hasattr(self, 'uuid_version_var') and hasattr(self, 'uuid_namebased_frame'):
+            version = self.uuid_version_var.get()
+            if version in [3, 5]:
+                # Show name-based settings for versions 3 and 5
+                self.uuid_namebased_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True, padx=(5, 0))
+            else:
+                # Hide name-based settings for versions 1 and 4
+                self.uuid_namebased_frame.pack_forget()
+    
+    def update_email_separator_field(self):
+        """Update email separator field visibility based on selected type."""
+        if hasattr(self, 'email_separator_type_var') and hasattr(self, 'email_separator_frame'):
+            separator_type = self.email_separator_type_var.get()
+            if separator_type == "custom":
+                # Show separator field for custom separator
+                self.email_separator_frame.pack(fill=tk.X, padx=10, pady=5)
+            else:
+                # Hide separator field for list format
+                self.email_separator_frame.pack_forget()
+    
+    def update_email_domain_field(self):
+        """Update email domain field visibility based on selected type."""
+        if hasattr(self, 'email_domain_type_var') and hasattr(self, 'email_domain_frame'):
+            domain_type = self.email_domain_type_var.get()
+            if domain_type == "custom":
+                # Show domain field for custom domain
+                self.email_domain_frame.pack(fill=tk.X, padx=10, pady=5)
+            else:
+                # Hide domain field for random domain
+                self.email_domain_frame.pack_forget()
+    
+    def update_percentages(self, *args):
+        """Update percentage labels and ensure they add up to 100%."""
+        if hasattr(self, 'pw_letters_percent_var'):
+            letters_percent = self.pw_letters_percent_var.get()
+            numbers_percent = self.pw_numbers_percent_var.get()
+            symbols_percent = self.pw_symbols_percent_var.get()
+            
+            total = letters_percent + numbers_percent + symbols_percent
+            
+            # Update labels
+            self.pw_letters_label.config(text=f"{letters_percent}%")
+            self.pw_numbers_label.config(text=f"{numbers_percent}%")
+            self.pw_symbols_label.config(text=f"{symbols_percent}%")
+            
+            # Update total label with color coding
+            if total == 100:
+                self.pw_total_label.config(text=f"{total}%", foreground="green")
+            else:
+                self.pw_total_label.config(text=f"{total}%", foreground="red")
+    
+    def generate_password(self):
+        """Generate a password and update the output."""
+        try:
+            length = int(self.pw_len_var.get())
+            numbers = self.pw_num_var.get()
+            symbols = self.pw_sym_var.get()
+            letters_percent = self.pw_letters_percent_var.get()
+            numbers_percent = self.pw_numbers_percent_var.get()
+            symbols_percent = self.pw_symbols_percent_var.get()
+            
+            settings = {
+                "length": length,
+                "numbers": numbers,
+                "symbols": symbols,
+                "letters_percent": letters_percent,
+                "numbers_percent": numbers_percent,
+                "symbols_percent": symbols_percent
+            }
+            
+            result = self.generator_tools.strong_password("", settings)
+            self.main_app.update_output_text(result)
+            
+            # Save settings
+            self.save_settings()
+            
+        except ValueError:
+            self.main_app.update_output_text("Error: Invalid password length")
+    
+    def generate_repeated_text(self):
+        """Generate repeated text and update the output."""
+        try:
+            # Get input text
+            active_input_tab = self.main_app.input_tabs[self.main_app.input_notebook.index(self.main_app.input_notebook.select())]
+            input_text = active_input_tab.text.get("1.0", tk.END).strip()
+            
+            if not input_text:
+                self.main_app.update_output_text("Error: No input text provided")
+                return
+            
+            times = int(self.repeat_times_var.get())
+            separator = self.repeat_sep_var.get()
+            
+            settings = {
+                "times": times,
+                "separator": separator
+            }
+            
+            result = self.generator_tools.repeating_text(input_text, settings)
+            self.main_app.update_output_text(result)
+            
+            # Save settings
+            self.save_settings()
+            
+        except ValueError:
+            self.main_app.update_output_text("Error: Invalid repeat times value")
+    
+    def generate_lorem_ipsum(self):
+        """Generate Lorem Ipsum text and update the output."""
+        try:
+            count = int(self.lorem_count_var.get())
+            text_type = self.lorem_type_var.get()
+            format_type = self.lorem_format_var.get()
+            ordered = self.lorem_ordered_var.get()
+            
+            settings = {
+                "count": count,
+                "type": text_type,
+                "format": format_type,
+                "ordered": ordered
+            }
+            
+            result = self.generator_tools.lorem_ipsum("", settings)
+            self.main_app.update_output_text(result)
+            
+            # Save settings
+            self.save_settings()
+            
+        except ValueError:
+            self.main_app.update_output_text("Error: Invalid count value")
+    
+    def generate_uuid(self):
+        """Generate UUID/GUID and update the output."""
+        try:
+            version = self.uuid_version_var.get()
+            format_type = self.uuid_format_var.get()
+            case = self.uuid_case_var.get()
+            count = int(self.uuid_count_var.get())
+            namespace = self.uuid_namespace_var.get()
+            name = self.uuid_name_var.get()
+            
+            settings = {
+                "version": version,
+                "format": format_type,
+                "case": case,
+                "count": count,
+                "namespace": namespace,
+                "name": name
+            }
+            
+            result = self.generator_tools.uuid_generator("", settings)
+            self.main_app.update_output_text(result)
+            
+            # Save settings
+            self.save_settings()
+            
+        except ValueError:
+            self.main_app.update_output_text("Error: Invalid count value")
+    
+    def generate_emails(self):
+        """Generate random emails and update the output."""
+        try:
+            count = int(self.email_count_var.get())
+            separator_type = self.email_separator_type_var.get()
+            separator = self.email_separator_var.get()
+            domain_type = self.email_domain_type_var.get()
+            domain = self.email_domain_var.get()
+            
+            settings = {
+                "count": count,
+                "separator_type": separator_type,
+                "separator": separator,
+                "domain_type": domain_type,
+                "domain": domain
+            }
+            
+            result = self.generator_tools.random_email_generator("", settings)
+            self.main_app.update_output_text(result)
+            
+            # Save settings
+            self.save_settings()
+            
+        except ValueError:
+            self.main_app.update_output_text("Error: Invalid count value")
+    
+    def save_settings(self):
+        """Save current settings to the main app."""
+        if not self.main_app:
+            return
+        
+        # Ensure the Generator Tools settings exist
+        if "Generator Tools" not in self.main_app.settings["tool_settings"]:
+            self.main_app.settings["tool_settings"]["Generator Tools"] = {}
+        
+        # Save Strong Password Generator settings
+        try:
+            self.main_app.settings["tool_settings"]["Generator Tools"]["Strong Password Generator"] = {
+                "length": int(self.pw_len_var.get()),
+                "numbers": self.pw_num_var.get(),
+                "symbols": self.pw_sym_var.get(),
+                "letters_percent": self.pw_letters_percent_var.get(),
+                "numbers_percent": self.pw_numbers_percent_var.get(),
+                "symbols_percent": self.pw_symbols_percent_var.get()
+            }
+        except (ValueError, AttributeError):
+            pass
+        
+        # Save Repeating Text Generator settings
+        try:
+            self.main_app.settings["tool_settings"]["Generator Tools"]["Repeating Text Generator"] = {
+                "times": int(self.repeat_times_var.get()),
+                "separator": self.repeat_sep_var.get()
+            }
+        except (ValueError, AttributeError):
+            pass
+        
+        # Save Lorem Ipsum Generator settings
+        try:
+            self.main_app.settings["tool_settings"]["Generator Tools"]["Lorem Ipsum Generator"] = {
+                "count": int(self.lorem_count_var.get()),
+                "type": self.lorem_type_var.get(),
+                "format": self.lorem_format_var.get(),
+                "ordered": self.lorem_ordered_var.get()
+            }
+        except (ValueError, AttributeError):
+            pass
+        
+        # Save UUID/GUID Generator settings
+        try:
+            self.main_app.settings["tool_settings"]["Generator Tools"]["UUID/GUID Generator"] = {
+                "version": self.uuid_version_var.get(),
+                "format": self.uuid_format_var.get(),
+                "case": self.uuid_case_var.get(),
+                "count": int(self.uuid_count_var.get()),
+                "namespace": self.uuid_namespace_var.get(),
+                "name": self.uuid_name_var.get()
+            }
+        except (ValueError, AttributeError):
+            pass
+        
+        # Save Random Email Generator settings
+        try:
+            self.main_app.settings["tool_settings"]["Generator Tools"]["Random Email Generator"] = {
+                "count": int(self.email_count_var.get()),
+                "separator_type": self.email_separator_type_var.get(),
+                "separator": self.email_separator_var.get(),
+                "domain_type": self.email_domain_type_var.get(),
+                "domain": self.email_domain_var.get()
+            }
+        except (ValueError, AttributeError):
+            pass
+        
+        # Save ASCII Art Generator settings
+        try:
+            if hasattr(self.main_app, 'ascii_art_generator') and self.main_app.ascii_art_generator:
+                if "ASCII Art Generator" not in self.main_app.settings["tool_settings"]:
+                    self.main_app.settings["tool_settings"]["ASCII Art Generator"] = {}
+                # Settings are saved by the widget itself
+        except (ValueError, AttributeError):
+            pass
+        
+        # Save Hash Generator settings
+        try:
+            if hasattr(self.main_app, 'hash_generator') and self.main_app.hash_generator:
+                if "Hash Generator" not in self.main_app.settings["tool_settings"]:
+                    self.main_app.settings["tool_settings"]["Hash Generator"] = {}
+                # Settings are saved by the widget itself
+        except (ValueError, AttributeError):
+            pass
+        
+        # Save Slug Generator settings
+        try:
+            if hasattr(self.main_app, 'slug_generator') and self.main_app.slug_generator:
+                if "Slug Generator" not in self.main_app.settings["tool_settings"]:
+                    self.main_app.settings["tool_settings"]["Slug Generator"] = {}
+                # Settings are saved by the widget itself
+        except (ValueError, AttributeError):
+            pass
+        
+        # Save settings to file
+        self.main_app.save_settings()
+    
+    def create_ascii_art_generator_tab(self):
+        """Create the ASCII Art Generator tab."""
+        tab_frame = ttk.Frame(self.notebook)
+        self.notebook.add(tab_frame, text="ASCII Art Generator")
+        
+        try:
+            from tools.ascii_art_generator import ASCIIArtGenerator
+            if hasattr(self.main_app, 'ascii_art_generator') and self.main_app.ascii_art_generator:
+                widget = self.main_app.ascii_art_generator.create_widget(tab_frame, self.main_app)
+                widget.pack(fill=tk.BOTH, expand=True)
+            else:
+                ttk.Label(tab_frame, text="ASCII Art Generator module not available").pack(padx=10, pady=10)
+        except ImportError:
+            ttk.Label(tab_frame, text="ASCII Art Generator module not available").pack(padx=10, pady=10)
+    
+    def create_hash_generator_tab(self):
+        """Create the Hash Generator tab."""
+        tab_frame = ttk.Frame(self.notebook)
+        self.notebook.add(tab_frame, text="Hash Generator")
+        
+        try:
+            from tools.hash_generator import HashGenerator
+            if hasattr(self.main_app, 'hash_generator') and self.main_app.hash_generator:
+                widget = self.main_app.hash_generator.create_widget(tab_frame, self.main_app)
+                widget.pack(fill=tk.BOTH, expand=True)
+            else:
+                ttk.Label(tab_frame, text="Hash Generator module not available").pack(padx=10, pady=10)
+        except ImportError:
+            ttk.Label(tab_frame, text="Hash Generator module not available").pack(padx=10, pady=10)
+    
+    def create_slug_generator_tab(self):
+        """Create the Slug Generator tab."""
+        tab_frame = ttk.Frame(self.notebook)
+        self.notebook.add(tab_frame, text="Slug Generator")
+        
+        try:
+            from tools.slug_generator import SlugGenerator
+            if hasattr(self.main_app, 'slug_generator') and self.main_app.slug_generator:
+                widget = self.main_app.slug_generator.create_widget(tab_frame, self.main_app)
+                widget.pack(fill=tk.BOTH, expand=True)
+            else:
+                ttk.Label(tab_frame, text="Slug Generator module not available").pack(padx=10, pady=10)
+        except ImportError:
+            ttk.Label(tab_frame, text="Slug Generator module not available").pack(padx=10, pady=10)