main.py

#!/usr/bin/env python3
"""
Codebase Parser with GUI - Fixed Version
Advanced code documentation generator with file explorer interface
Supports multiple programming languages with checkboxes for selective parsing
"""

import os
import sys
import threading
from pathlib import Path
from typing import Dict, List, Set, Optional
import tkinter as tk
from tkinter import ttk, filedialog, messagebox, scrolledtext
import platform

class CodebaseParser:
    def __init__(self):
        self.code_extensions = {
            '.py', '.js', '.ts', '.tsx', '.jsx', '.java', '.cpp', '.cc', '.cxx', 
            '.c', '.h', '.hpp', '.cs', '.php', '.rb', '.go', '.rs', '.kt', 
            '.swift', '.m', '.mm', '.scala', '.clj', '.hs', '.ml', '.fs',
            '.dart', '.lua', '.r', '.pl', '.sh', '.bash', '.zsh', '.fish',
            '.sql', '.json', '.xml', '.yaml', '.yml', '.toml', '.ini', '.cfg',
            '.vue', '.svelte', '.elm', '.coffee', '.scss', '.sass', '.less'
        }
        
        self.ignore_dirs = {
            'node_modules', '__pycache__', '.git', '.svn', '.hg', 'build', 
            'dist', 'target', 'bin', 'obj', '.gradle', '.idea', '.vscode',
            'vendor', 'coverage', '.nyc_output', 'logs', 'tmp', 'temp',
            '.next', '.nuxt', 'out', 'venv', 'env', '.env', '$RECYCLE.BIN',
            'System Volume Information', 'Windows', 'Program Files', 
            'Program Files (x86)', 'ProgramData'
        }
        
    def should_ignore_path(self, path: Path) -> bool:
        """Check if path should be ignored"""
        try:
            for parent in path.parents:
                if parent.name in self.ignore_dirs:
                    return True
            return path.is_dir() and path.name in self.ignore_dirs
        except:
            return True

    def is_code_file(self, file_path: Path) -> bool:
        return file_path.suffix.lower() in self.code_extensions

    def get_language_from_extension(self, extension: str) -> str:
        lang_map = {
            '.py': 'Python', '.js': 'JavaScript', '.ts': 'TypeScript', 
            '.tsx': 'TypeScript React', '.jsx': 'JavaScript React',
            '.java': 'Java', '.cpp': 'C++', '.cc': 'C++', '.cxx': 'C++',
            '.c': 'C', '.h': 'C/C++ Header', '.hpp': 'C++ Header',
            '.cs': 'C#', '.php': 'PHP', '.rb': 'Ruby', '.go': 'Go',
            '.rs': 'Rust', '.kt': 'Kotlin', '.swift': 'Swift', '.vue': 'Vue',
            '.svelte': 'Svelte', '.elm': 'Elm', '.sql': 'SQL'
        }
        return lang_map.get(extension.lower(), extension[1:].upper() if extension else 'Unknown')

    def read_file_content(self, file_path: Path) -> Optional[str]:
        try:
            with open(file_path, 'r', encoding='utf-8') as f:
                return f.read()
        except UnicodeDecodeError:
            try:
                with open(file_path, 'r', encoding='latin-1') as f:
                    return f.read()
            except:
                return f"Error: Unable to read file"
        except Exception as e:
            return f"Error: {str(e)}"

    def generate_separator(self, text: str, char: str = '-', length: int = 43) -> str:
        return char * length + text + char * length

    def generate_output(self, selected_paths: List[Path], output_file: str) -> tuple:
        try:
            files_by_dir = {}
            total_files = 0
            
            # Organize files by directory
            for path in selected_paths:
                try:
                    if path.is_file() and self.is_code_file(path):
                        parent = str(path.parent)
                        if parent not in files_by_dir:
                            files_by_dir[parent] = []
                        files_by_dir[parent].append(path)
                        total_files += 1
                    elif path.is_dir():
                        for item in path.rglob('*'):
                            if item.is_file() and self.is_code_file(item) and not self.should_ignore_path(item):
                                parent = str(item.parent)
                                if parent not in files_by_dir:
                                    files_by_dir[parent] = []
                                if item not in files_by_dir[parent]:
                                    files_by_dir[parent].append(item)
                                    total_files += 1
                except Exception as e:
                    continue
            
            if total_files == 0:
                return (False, "No code files found in selected paths")
            
            # Generate output
            with open(output_file, 'w', encoding='utf-8') as f:
                # Write header
                f.write("=" * 100 + "\n")
                f.write("CODEBASE DOCUMENTATION\n")
                f.write("=" * 100 + "\n")
                f.write(f"Total Files: {total_files}\n")
                f.write(f"Total Directories: {len(files_by_dir)}\n")
                f.write(f"Output Generated: {Path(output_file).absolute()}\n")
                f.write("=" * 100 + "\n\n")
                
                # Write structure
                f.write("Code Structure:\n")
                for directory in sorted(files_by_dir.keys()):
                    f.write(f"\n{directory}\n")
                    for file_path in sorted(files_by_dir[directory], key=lambda x: x.name):
                        f.write(f"  {file_path.name}\n")
                
                f.write("\n" + "=" * 100 + "\n\n")
                
                # Write file contents
                for directory in sorted(files_by_dir.keys()):
                    files = sorted(files_by_dir[directory], key=lambda x: x.name)
                    
                    for file_path in files:
                        file_name = file_path.stem
                        extension = file_path.suffix
                        language = self.get_language_from_extension(extension)
                        
                        # Section header
                        section_header = f"{Path(directory).name}/{file_name}"
                        f.write(self.generate_separator(section_header) + "\n")
                        f.write(f"File: {file_path.name}\n")
                        f.write(f"Path: {file_path}\n")
                        f.write(f"Language: {language}\n")
                        f.write("-" * 100 + "\n")
                        
                        # File content
                        content = self.read_file_content(file_path)
                        f.write(content if content else "// Unable to read file\n")
                        f.write("\n" + "=" * 100 + "\n\n")
            
            return (True, f"Successfully generated {output_file}\nProcessed {total_files} files")
            
        except Exception as e:
            return (False, f"Error generating output: {str(e)}")


class FileTreeView(ttk.Frame):
    def __init__(self, parent, parser):
        super().__init__(parent)
        self.parser = parser
        self.checked_items = {}  # item_id -> (path, checked_state)
        self.expanded_items = set()
        
        # Create UI
        self.create_widgets()
        
    def create_widgets(self):
        # Toolbar
        toolbar = ttk.Frame(self)
        toolbar.pack(side=tk.TOP, fill=tk.X, padx=5, pady=5)
        
        # Buttons
        ttk.Button(toolbar, text="Browse Folder", command=self.browse_folder).pack(side=tk.LEFT, padx=2)
        ttk.Button(toolbar, text="Refresh", command=self.refresh_tree).pack(side=tk.LEFT, padx=2)
        ttk.Button(toolbar, text="Clear All", command=self.clear_all).pack(side=tk.LEFT, padx=2)
        
        # Search frame
        search_frame = ttk.Frame(toolbar)
        search_frame.pack(side=tk.RIGHT, padx=5)
        ttk.Label(search_frame, text="Filter:").pack(side=tk.LEFT)
        self.search_var = tk.StringVar()
        search_entry = ttk.Entry(search_frame, textvariable=self.search_var, width=20)
        search_entry.pack(side=tk.LEFT, padx=5)
        search_entry.bind('<Return>', self.on_search)
        ttk.Button(search_frame, text="Search", command=self.on_search).pack(side=tk.LEFT)
        
        # Create frame for tree and scrollbar
        tree_frame = ttk.Frame(self)
        tree_frame.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        # Scrollbars
        vsb = ttk.Scrollbar(tree_frame, orient="vertical")
        hsb = ttk.Scrollbar(tree_frame, orient="horizontal")
        
        # Treeview
        self.tree = ttk.Treeview(
            tree_frame,
            yscrollcommand=vsb.set,
            xscrollcommand=hsb.set,
            selectmode='browse'
        )
        
        vsb.config(command=self.tree.yview)
        hsb.config(command=self.tree.xview)
        
        # Layout
        self.tree.grid(row=0, column=0, sticky='nsew')
        vsb.grid(row=0, column=1, sticky='ns')
        hsb.grid(row=1, column=0, sticky='ew')
        
        tree_frame.grid_rowconfigure(0, weight=1)
        tree_frame.grid_columnconfigure(0, weight=1)
        
        # Configure columns
        self.tree.heading('#0', text='File System (Click checkbox to select, double-click to expand)', anchor=tk.W)
        self.tree.column('#0', width=500, minwidth=200)
        
        # Bind events
        self.tree.bind('<Button-1>', self.on_click)
        self.tree.bind('<<TreeviewOpen>>', self.on_expand)
        
        # Status bar
        self.status_var = tk.StringVar(value="Ready - Browse for a folder to start")
        status_bar = ttk.Label(self, textvariable=self.status_var, relief=tk.SUNKEN)
        status_bar.pack(side=tk.BOTTOM, fill=tk.X)
        
        # Initialize with quick access
        self.populate_quick_access()
        
    def get_icon(self, path: Path) -> str:
        """Get icon character for file/folder"""
        if path.is_dir():
            return "📁"
        elif self.parser.is_code_file(path):
            return "📄"
        else:
            return "📋"
    
    def populate_quick_access(self):
        """Populate with quick access locations"""
        self.tree.delete(*self.tree.get_children())
        
        # Add home directory
        home = Path.home()
        home_node = self.insert_node('', home, f"🏠 Home ({home})")
        
        # Add Desktop if exists
        desktop = home / "Desktop"
        if desktop.exists():
            self.insert_node('', desktop, "🖥️ Desktop")
        
        # Add Documents if exists
        documents = home / "Documents"
        if documents.exists():
            self.insert_node('', documents, "📚 Documents")
        
        # Add common project locations
        if platform.system() == 'Windows':
            # Add drives
            import string
            for letter in string.ascii_uppercase:
                drive = Path(f"{letter}:\\")
                if drive.exists():
                    try:
                        drive.stat()  # Check if accessible
                        self.insert_node('', drive, f"💾 {letter}:\\")
                    except:
                        pass
    
    def insert_node(self, parent, path: Path, display_name: str = None):
        """Insert a node into the tree"""
        if display_name is None:
            icon = self.get_icon(path)
            display_name = f"☐ {icon} {path.name if path.name else str(path)}"
        else:
            display_name = f"☐ {display_name}"
        
        item_id = self.tree.insert(parent, 'end', text=display_name, open=False)
        self.checked_items[item_id] = (str(path), False)
        
        # Add dummy child for directories to make them expandable
        if path.is_dir():
            self.tree.insert(item_id, 'end', text='')
        
        return item_id
    
    def on_expand(self, event):
        """Handle node expansion"""
        item = self.tree.focus()
        if not item or item in self.expanded_items:
            return
        
        # Mark as expanded
        self.expanded_items.add(item)
        
        # Remove dummy child
        children = self.tree.get_children(item)
        if children and not self.checked_items.get(children[0]):
            self.tree.delete(children[0])
        
        # Populate real children
        if item in self.checked_items:
            path_str = self.checked_items[item][0]
            self.populate_children(item, Path(path_str))
    
    def populate_children(self, parent_item, path: Path):
        """Populate children of a directory"""
        if not path.exists() or not path.is_dir():
            return
        
        try:
            items = []
            for item in path.iterdir():
                # Skip hidden files (except common dev folders)
                if item.name.startswith('.') and item.name not in ['.git', '.vscode', '.idea']:
                    continue
                
                # Skip ignored directories
                if self.parser.should_ignore_path(item):
                    continue
                
                items.append(item)
            
            # Sort: directories first, then by name
            items.sort(key=lambda x: (not x.is_dir(), x.name.lower()))
            
            # Limit to prevent overwhelming the UI
            if len(items) > 500:
                self.tree.insert(parent_item, 'end', 
                               text=f'⚠️ Too many items ({len(items)}) - showing first 500')
                items = items[:500]
            
            for item in items:
                self.insert_node(parent_item, item)
                
        except PermissionError:
            self.tree.insert(parent_item, 'end', text='⚠️ Permission Denied')
        except Exception as e:
            self.tree.insert(parent_item, 'end', text=f'⚠️ Error: {str(e)}')
    
    def on_click(self, event):
        """Handle clicks on tree items"""
        region = self.tree.identify_region(event.x, event.y)
        item = self.tree.identify_row(event.y)
        
        if not item or item not in self.checked_items:
            return
        
        # Get click region
        column = self.tree.identify_column(event.x)
        
        if region == "tree" and column == "#0":
            # Check if click is on checkbox area (first 30 pixels)
            if event.x < 30:
                self.toggle_checkbox(item)
                return "break"
    
    def toggle_checkbox(self, item):
        """Toggle checkbox state"""
        if item not in self.checked_items:
            return
        
        path_str, current_state = self.checked_items[item]
        new_state = not current_state
        
        # Update state
        self.checked_items[item] = (path_str, new_state)
        
        # Update visual
        text = self.tree.item(item, 'text')
        if new_state:
            new_text = text.replace('☐', '☑', 1)
        else:
            new_text = text.replace('☑', '☐', 1)
        
        self.tree.item(item, text=new_text)
        
        # Update children if expanded
        self.update_children_recursive(item, new_state)
        
        # Update status
        self.update_status()
    
    def update_children_recursive(self, parent, state):
        """Recursively update children checkbox state"""
        for child in self.tree.get_children(parent):
            if child in self.checked_items:
                path_str, _ = self.checked_items[child]
                self.checked_items[child] = (path_str, state)
                
                # Update visual
                text = self.tree.item(child, 'text')
                if state:
                    new_text = text.replace('☐', '☑', 1)
                else:
                    new_text = text.replace('☑', '☐', 1)
                self.tree.item(child, text=new_text)
                
                # Recurse
                self.update_children_recursive(child, state)
    
    def browse_folder(self):
        """Browse for a folder to add"""
        folder = filedialog.askdirectory(title="Select Folder to Parse")
        if folder:
            path = Path(folder)
            # Add to tree
            node = self.insert_node('', path, f"📂 {path.name} ({path})")
            # Auto-expand
            self.tree.item(node, open=True)
            self.on_expand(None)
            self.tree.focus(node)
            self.tree.selection_set(node)
            self.update_status()
    
    def refresh_tree(self):
        """Refresh the tree"""
        self.checked_items.clear()
        self.expanded_items.clear()
        self.populate_quick_access()
        self.update_status()
    
    def clear_all(self):
        """Clear all selections"""
        for item in self.checked_items:
            path_str, checked = self.checked_items[item]
            if checked:
                self.checked_items[item] = (path_str, False)
                text = self.tree.item(item, 'text')
                new_text = text.replace('☑', '☐', 1)
                self.tree.item(item, text=new_text)
        self.update_status()
    
    def on_search(self, event=None):
        """Search for items in tree"""
        search_text = self.search_var.get().lower().strip()
        if not search_text:
            messagebox.showinfo("Search", "Please enter a search term")
            return
        
        # Find matching items
        matches = []
        for item in self.checked_items:
            path_str = self.checked_items[item][0]
            if search_text in Path(path_str).name.lower():
                matches.append(item)
        
        if matches:
            # Focus on first match
            self.tree.selection_set(matches[0])
            self.tree.focus(matches[0])
            self.tree.see(matches[0])
            messagebox.showinfo("Search", f"Found {len(matches)} matches")
        else:
            messagebox.showinfo("Search", "No matches found")
    
    def update_status(self):
        """Update status bar"""
        count = sum(1 for _, checked in self.checked_items.values() if checked)
        self.status_var.set(f"Selected: {count} items")
    
    def get_checked_paths(self) -> List[Path]:
        """Get list of checked paths"""
        paths = []
        for item_id, (path_str, checked) in self.checked_items.items():
            if checked:
                paths.append(Path(path_str))
        return paths


class CodebaseParserGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("Codebase Parser - Professional Code Documentation Tool")
        self.root.geometry("1200x800")
        
        # Set minimum size
        self.root.minsize(900, 600)
        
        # Initialize parser
        self.parser = CodebaseParser()
        
        # Create UI
        self.create_menu()
        self.create_main_layout()
        
        # Configure styles
        self.configure_styles()
        
    def configure_styles(self):
        """Configure ttk styles"""
        style = ttk.Style()
        try:
            style.theme_use('clam')
        except:
            pass
        
    def create_menu(self):
        """Create menu bar"""
        menubar = tk.Menu(self.root)
        self.root.config(menu=menubar)
        
        # File menu
        file_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="File", menu=file_menu)
        file_menu.add_command(label="Browse Folder", command=lambda: self.file_tree.browse_folder())
        file_menu.add_command(label="Choose Output Location", command=self.choose_output_location)
        file_menu.add_separator()
        file_menu.add_command(label="Exit", command=self.root.quit)
        
        # View menu
        view_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="View", menu=view_menu)
        view_menu.add_command(label="Refresh", command=lambda: self.file_tree.refresh_tree())
        view_menu.add_command(label="Clear Selections", command=lambda: self.file_tree.clear_all())
        
        # Help menu
        help_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="Help", menu=help_menu)
        help_menu.add_command(label="How to Use", command=self.show_help)
        help_menu.add_command(label="About", command=self.show_about)
    
    def create_main_layout(self):
        """Create main layout"""
        # Main container
        main_container = ttk.PanedWindow(self.root, orient=tk.HORIZONTAL)
        main_container.pack(fill=tk.BOTH, expand=True)
        
        # Left panel - File tree
        left_panel = ttk.Frame(main_container)
        main_container.add(left_panel, weight=3)
        
        self.file_tree = FileTreeView(left_panel, self.parser)
        self.file_tree.pack(fill=tk.BOTH, expand=True)
        
        # Right panel - Options and output
        right_panel = ttk.Frame(main_container)
        main_container.add(right_panel, weight=1)
        
        # Options frame
        options_frame = ttk.LabelFrame(right_panel, text="Options", padding=10)
        options_frame.pack(fill=tk.X, padx=10, pady=10)
        
        # Output location
        ttk.Label(options_frame, text="Output File:").pack(anchor=tk.W, pady=5)
        
        output_frame = ttk.Frame(options_frame)
        output_frame.pack(fill=tk.X, pady=5)
        
        self.output_var = tk.StringVar(value=str(Path.cwd() / "code.txt"))
        output_entry = ttk.Entry(output_frame, textvariable=self.output_var)
        output_entry.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=(0, 5))
        
        ttk.Button(output_frame, text="Browse", 
                  command=self.choose_output_location).pack(side=tk.RIGHT)
        
        # File extensions
        ttk.Label(options_frame, text="Custom Extensions:").pack(anchor=tk.W, pady=(10, 5))
        self.extensions_var = tk.StringVar()
        ttk.Entry(options_frame, textvariable=self.extensions_var).pack(fill=tk.X, pady=5)
        ttk.Label(options_frame, text="(e.g., .txt,.md,.conf)", 
                 font=('TkDefaultFont', 8)).pack(anchor=tk.W)
        
        # Generate button
        self.generate_btn = ttk.Button(
            options_frame, 
            text="📝 Generate Documentation", 
            command=self.generate_output
        )
        self.generate_btn.pack(fill=tk.X, pady=20)
        
        # Quick stats
        stats_frame = ttk.LabelFrame(options_frame, text="Quick Stats", padding=5)
        stats_frame.pack(fill=tk.X, pady=10)
        
        self.stats_var = tk.StringVar(value="No selections yet")
        ttk.Label(stats_frame, textvariable=self.stats_var, wraplength=200).pack()
        
        # Progress frame
        progress_frame = ttk.LabelFrame(right_panel, text="Progress", padding=10)
        progress_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        self.progress_var = tk.StringVar(value="Ready to generate documentation")
        ttk.Label(progress_frame, textvariable=self.progress_var, 
                 wraplength=250).pack(anchor=tk.W, pady=5)
        
        self.progressbar = ttk.Progressbar(progress_frame, mode='indeterminate')
        self.progressbar.pack(fill=tk.X, pady=10)
        
        # Log text
        log_label = ttk.Label(progress_frame, text="Log:")
        log_label.pack(anchor=tk.W, pady=(10, 5))
        
        self.log_text = scrolledtext.ScrolledText(
            progress_frame, 
            height=15, 
            wrap=tk.WORD,
            font=('Courier', 9)
        )
        self.log_text.pack(fill=tk.BOTH, expand=True)
        
        # Update stats periodically
        self.update_stats()
        
    def update_stats(self):
        """Update statistics"""
        checked = self.file_tree.get_checked_paths()
        if checked:
            self.stats_var.set(f"Selected: {len(checked)} paths")
        else:
            self.stats_var.set("No selections yet")
        
        # Schedule next update
        self.root.after(1000, self.update_stats)
        
    def choose_output_location(self):
        """Choose output file location"""
        filename = filedialog.asksaveasfilename(
            title="Choose Output Location",
            defaultextension=".txt",
            filetypes=[("Text Files", "*.txt"), ("All Files", "*.*")],
            initialfile="code.txt"
        )
        
        if filename:
            self.output_var.set(filename)
            self.log(f"Output location: {filename}")
    
    def log(self, message):
        """Add message to log"""
        self.log_text.insert(tk.END, f"{message}\n")
        self.log_text.see(tk.END)
        self.root.update_idletasks()
    
    def generate_output(self):
        """Generate documentation output"""
        checked_paths = self.file_tree.get_checked_paths()
        
        if not checked_paths:
            messagebox.showwarning("No Selection", 
                                 "Please select at least one file or folder.\n\n"
                                 "Click the checkbox (☐) next to folders to select them.")
            return
        
        output_file = self.output_var.get()
        if not output_file:
            messagebox.showwarning("No Output File", "Please specify an output file")
            return
        
        # Add custom extensions
        custom_exts = self.extensions_var.get()
        if custom_exts:
            for ext in custom_exts.split(','):
                ext = ext.strip()
                if ext and not ext.startswith('.'):
                    ext = '.' + ext
                if ext:
                    self.parser.code_extensions.add(ext.lower())
        
        # Disable generate button
        self.generate_btn.config(state='disabled')
        self.progressbar.start()
        
        self.log("\n" + "="*50)
        self.log("Starting documentation generation...")
        self.log(f"Selected {len(checked_paths)} items")
        self.log(f"Output file: {output_file}")
        
        # Run in thread to keep UI responsive
        def generate_thread():
            success, message = self.parser.generate_output(checked_paths, output_file)
            
            # Update UI in main thread
            self.root.after(0, lambda: self.generation_complete(success, message))
        
        thread = threading.Thread(target=generate_thread, daemon=True)
        thread.start()
    
    def generation_complete(self, success, message):
        """Called when generation is complete"""
        self.progressbar.stop()
        self.generate_btn.config(state='normal')
        
        if success:
            self.log("✓ " + message)
            self.progress_var.set("Documentation generated successfully!")
            
            # Ask to open file
            if messagebox.askyesno("Success", 
                                  f"{message}\n\nWould you like to open the output file?"):
                try:
                    if platform.system() == 'Windows':
                        os.startfile(self.output_var.get())
                    elif platform.system() == 'Darwin':
                        os.system(f'open "{self.output_var.get()}"')
                    else:
                        os.system(f'xdg-open "{self.output_var.get()}"')
                except:
                    pass
        else:
            self.log("✗ " + message)
            self.progress_var.set("Error occurred during generation")
            messagebox.showerror("Error", message)
    
    def show_about(self):
        """Show about dialog"""
        about_text = """
Codebase Parser GUI v2.5

Professional code documentation tool with 
file explorer interface.

Features:
• Multi-language support
• Selective file/folder parsing
• Full directory tree navigation
• Customizable output format
• Built-in code analysis

Created with Python & Tkinter
        """
        messagebox.showinfo("About", about_text)
    
    def show_help(self):
        """Show help dialog"""
        help_text = """How to Use Codebase Parser

STEP 1: BROWSE & SELECT
• Click "Browse Folder" to add a project folder
• Navigate through the file tree
• Click checkboxes (☐) next to files/folders to select them

2. SELECT
   • Click checkboxes next to items to include them
   • Use "Select All" to select everything
   • Selecting a folder selects all its contents

3. CONFIGURE
   • Set output file location
   • Add custom file extensions if needed

4. GENERATE
   • Click "Generate Documentation" button
   • Wait for completion
   • Open the generated code.txt file

Tips:
• The tool automatically ignores node_modules, .git, etc.
• Only code files are processed
• Large projects may take some time to process
        """
        
        help_window = tk.Toplevel(self.root)
        help_window.title("How to Use")
        help_window.geometry("500x500")
        
        text = scrolledtext.ScrolledText(help_window, wrap=tk.WORD, font=('TkDefaultFont', 10))
        text.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        text.insert('1.0', help_text)
        text.config(state='disabled')
        
        ttk.Button(help_window, text="Close", 
                  command=help_window.destroy).pack(pady=10)


def main():
    root = tk.Tk()
    app = CodebaseParserGUI(root)
    root.mainloop()


if __name__ == "__main__":
    main()