ntc-dev-kit 1.0.0__py3-none-any.whl

ntc/cli_enhanced.py

@@ -0,0 +1,820 @@
+import argparse
+import os
+import sys
+import msvcrt
+import time
+from colorama import Fore, Back, Style, init
+from ntc.templates.drf_structure.main import init_drf_project, init_drf_project_in_current_dir
+from ntc.templates.react_structure.main import init_react_project, init_react_project_in_current_dir
+from ntc.templates.react_admin.main import init_react_admin_project, init_react_admin_project_in_current_dir
+from ntc.templates.nextjs.main import init_nextjs_project, init_nextjs_project_in_current_dir
+from ntc.templates.flutter.main import init_flutter_project, init_flutter_project_in_current_dir
+from ntc.composer.main import compose_project, compose_project_in_current_dir, start_services
+from ntc.app_creator import create_app_structure
+
+# Initialize colorama for cross-platform colored output
+init(autoreset=True)
+
+def print_banner():
+    """Display the clean NTC welcome banner."""
+    print(f"""
+{Fore.CYAN}╔{'═' * 75}╗{Style.RESET_ALL}
+{Fore.CYAN}║{' ' * 75}║{Style.RESET_ALL}
+{Fore.CYAN}║{' ' * 25}{Fore.YELLOW}{Style.BRIGHT}███╗   ██╗████████╗ ██████╗{' ' * 23}{Fore.CYAN}║{Style.RESET_ALL}
+{Fore.CYAN}║{' ' * 25}{Fore.YELLOW}{Style.BRIGHT}████╗  ██║╚══██╔══╝██╔════╝{' ' * 23}{Fore.CYAN}║{Style.RESET_ALL}
+{Fore.CYAN}║{' ' * 25}{Fore.YELLOW}{Style.BRIGHT}██╔██╗ ██║   ██║   ██║     {' ' * 23}{Fore.CYAN}║{Style.RESET_ALL}
+{Fore.CYAN}║{' ' * 25}{Fore.YELLOW}{Style.BRIGHT}██║╚██╗██║   ██║   ██║     {' ' * 23}{Fore.CYAN}║{Style.RESET_ALL}
+{Fore.CYAN}║{' ' * 25}{Fore.YELLOW}{Style.BRIGHT}██║ ╚████║   ██║   ╚██████╗{' ' * 23}{Fore.CYAN}║{Style.RESET_ALL}
+{Fore.CYAN}║{' ' * 25}{Fore.YELLOW}{Style.BRIGHT}╚═╝  ╚═══╝   ╚═╝    ╚═════╝{' ' * 23}{Fore.CYAN}║{Style.RESET_ALL}
+{Fore.CYAN}║{' ' * 75}║{Style.RESET_ALL}
+{Fore.CYAN}║{' ' * 24}{Fore.GREEN}{Style.BRIGHT}🚀 NEXENT TOOLKIT CONSOLE 🚀{' ' * 23}{Fore.CYAN}║{Style.RESET_ALL}
+{Fore.CYAN}║{' ' * 75}║{Style.RESET_ALL}
+{Fore.CYAN}║{' ' * 16}{Fore.WHITE}The ultimate toolkit for API-driven development{' ' * 12}{Fore.CYAN}║{Style.RESET_ALL}
+{Fore.CYAN}║{' ' * 75}║{Style.RESET_ALL}
+{Fore.CYAN}║{' ' * 10}{Fore.GREEN}Backend:{Fore.WHITE} Django/DRF, Laravel  {Fore.BLUE}Frontend:{Fore.WHITE} React, Angular, Vue {Fore.CYAN}{' ' * 5}║{Style.RESET_ALL}
+{Fore.CYAN}║{' ' * 75}║{Style.RESET_ALL}
+{Fore.CYAN}╚{'═' * 75}╝{Style.RESET_ALL}""")
+    print()
+
+def print_welcome_message():
+    """Display a simple welcome message."""
+    print(f"   {Fore.BLUE}💡 Use arrow keys to navigate • Press Enter to select • Esc to exit{Style.RESET_ALL}")
+    print()
+
+def print_success(message):
+    """Print success message with green color and checkmark."""
+    print(f"{Fore.GREEN}✅ {message}{Style.RESET_ALL}")
+
+def print_error(message):
+    """Print error message with red color and X mark."""
+    print(f"{Fore.RED}❌ {message}{Style.RESET_ALL}")
+
+def print_warning(message):
+    """Print warning message with yellow color and warning sign."""
+    print(f"{Fore.YELLOW}⚠️  {message}{Style.RESET_ALL}")
+
+def print_info(message):
+    """Print info message with blue color and info icon."""
+    print(f"{Fore.CYAN}ℹ️  {message}{Style.RESET_ALL}")
+
+def print_question(message):
+    """Print question with bright white color and question mark."""
+    return input(f"{Fore.WHITE}{Style.BRIGHT}❓ {message}{Style.RESET_ALL}")
+
+def clear_screen():
+    """Clear the terminal screen."""
+    os.system('cls' if os.name == 'nt' else 'clear')
+
+def print_choice(number, description, selected=False):
+    """Print a numbered choice option with selection highlighting."""
+    if selected:
+        print(f"{Back.CYAN}{Fore.WHITE}{Style.BRIGHT} ► [{number}] {description} {Style.RESET_ALL}")
+    else:
+        print(f"   {Fore.YELLOW}[{number}]{Style.RESET_ALL} {Fore.WHITE}{description}{Style.RESET_ALL}")
+
+def print_menu_header(title, subtitle=""):
+    """Print an attractive menu header."""
+    width = 70
+    print(f"\n{Fore.CYAN}{'═' * width}{Style.RESET_ALL}")
+    print(f"{Fore.CYAN}║{' ' * ((width - len(title) - 2) // 2)}{Fore.YELLOW}{Style.BRIGHT}{title}{Fore.CYAN}{' ' * ((width - len(title) - 2) // 2)}║{Style.RESET_ALL}")
+    if subtitle:
+        print(f"{Fore.CYAN}║{' ' * ((width - len(subtitle) - 2) // 2)}{Fore.WHITE}{subtitle}{Fore.CYAN}{' ' * ((width - len(subtitle) - 2) // 2)}║{Style.RESET_ALL}")
+    print(f"{Fore.CYAN}{'═' * width}{Style.RESET_ALL}")
+
+def print_navigation_help():
+    """Print navigation instructions."""
+    print(f"\n{Fore.MAGENTA}🎮 Navigation:{Style.RESET_ALL}")
+    print(f"   {Fore.GREEN}↑/↓{Style.RESET_ALL} Navigate   {Fore.GREEN}Enter{Style.RESET_ALL} Select   {Fore.GREEN}Esc{Style.RESET_ALL} Exit")
+
+def animate_loading(message, duration=1.5):
+    """Show an animated loading message."""
+    frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    end_time = time.time() + duration
+    
+    while time.time() < end_time:
+        for frame in frames:
+            if time.time() >= end_time:
+                break
+            print(f"\r{Fore.CYAN}{frame} {message}{Style.RESET_ALL}", end="", flush=True)
+            time.sleep(0.1)
+    
+    print(f"\r{Fore.GREEN}✅ {message} Complete!{Style.RESET_ALL}")
+    time.sleep(0.5)
+
+def animate_progress(message, steps=None, duration=3.0):
+    """Show progress animation with percentage on the same line."""
+    frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    
+    if steps:
+        # Step-based progress
+        for i, step in enumerate(steps, 1):
+            progress = int((i / len(steps)) * 100)
+            for j in range(10):  # Show animation for each step
+                frame = frames[j % len(frames)]
+                print(f"\r{Fore.CYAN}{frame} {message}: {step} {Fore.YELLOW}[{progress}%]{Style.RESET_ALL}", end="", flush=True)
+                time.sleep(0.1)
+        print(f"\r{Fore.GREEN}✅ {message} Complete! {Fore.YELLOW}[100%]{Style.RESET_ALL}")
+    else:
+        # Time-based progress
+        start_time = time.time()
+        end_time = start_time + duration
+        
+        while time.time() < end_time:
+            elapsed = time.time() - start_time
+            progress = int((elapsed / duration) * 100)
+            frame = frames[int(elapsed * 10) % len(frames)]
+            
+            print(f"\r{Fore.CYAN}{frame} {message} {Fore.YELLOW}[{progress}%]{Style.RESET_ALL}", end="", flush=True)
+            time.sleep(0.1)
+        
+        print(f"\r{Fore.GREEN}✅ {message} Complete! {Fore.YELLOW}[100%]{Style.RESET_ALL}")
+    
+    print()  # New line after completion
+
+def animate_dependency_install(requirements_path=None, pip_command=None, env_type="system"):
+    """Show real dependency installation with progress animation."""
+    import subprocess
+    import threading
+    
+    if not requirements_path or not os.path.exists(requirements_path):
+        # Fallback to simulation if no requirements file
+        dependencies = [
+            "Resolving dependencies",
+            "Downloading packages", 
+            "Installing Django",
+            "Installing DRF",
+            "Installing Celery",
+            "Installing CORS headers",
+            "Configuring environment",
+            "Setting up database",
+            "Creating migrations",
+            "Finalizing setup"
+        ]
+        
+        print(f"\n{Fore.MAGENTA}📦 Installing Dependencies{Style.RESET_ALL}")
+        
+        for i, dep in enumerate(dependencies, 1):
+            progress = int((i / len(dependencies)) * 100)
+            
+            # Show animation for each dependency
+            for j in range(5):  # 5 animation cycles per dependency
+                frame = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"][j % 10]
+                # Clear line and print new content
+                print(f"\r{' ' * 80}\r{Fore.CYAN}{frame} {dep}... {Fore.YELLOW}[{progress}%]{Style.RESET_ALL}", end="", flush=True)
+                time.sleep(0.2)
+        
+        print(f"\r{' ' * 80}\r{Fore.GREEN}✅ All dependencies installed successfully! {Fore.YELLOW}[100%]{Style.RESET_ALL}")
+        print()
+        return
+    
+    # Real dependency installation with animation
+    print(f"\n{Fore.MAGENTA}📦 Installing Dependencies{Style.RESET_ALL}")
+    
+    # Determine the pip command to use
+    if pip_command is None:
+        # Default to system pip
+        pip_command = [sys.executable, "-m", "pip", "install", "-r", requirements_path]
+    
+    # Animation state
+    animation_running = True
+    install_complete = False
+    install_success = False
+    error_message = ""
+    
+    def run_pip_install():
+        nonlocal install_complete, install_success, error_message
+        try:
+            # Run pip install with suppressed output
+            result = subprocess.run(
+                pip_command,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            install_success = True
+        except subprocess.CalledProcessError as e:
+            install_success = False
+            error_message = str(e)
+        finally:
+            install_complete = True
+    
+    # Start installation in background thread
+    install_thread = threading.Thread(target=run_pip_install)
+    install_thread.start()
+    
+    # Show animation while installation runs
+    frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    frame_index = 0
+    
+    while not install_complete:
+        frame = frames[frame_index % len(frames)]
+        # Clear line completely before writing new content
+        env_msg = f" ({env_type} environment)" if env_type != "system" else ""
+        print(f"\r{' ' * 80}\r{Fore.CYAN}{frame} Installing packages{env_msg}...{Style.RESET_ALL}", end="", flush=True)
+        time.sleep(0.1)
+        frame_index += 1
+    
+    # Wait for thread to complete
+    install_thread.join()
+    
+    # Show final result
+    if install_success:
+        print(f"\r{' ' * 80}\r{Fore.GREEN}✅ All dependencies installed successfully!{Style.RESET_ALL}")
+    else:
+        print(f"\r{' ' * 80}\r{Fore.RED}❌ Failed to install dependencies: {error_message}{Style.RESET_ALL}")
+        print(f"{Fore.YELLOW}💡 You can manually install later with: pip install -r requirements.txt{Style.RESET_ALL}")
+    
+    print()
+
+def get_key():
+    """Get a single keypress from user."""
+    if os.name == 'nt':  # Windows
+        key = msvcrt.getch()
+        if key == b'\xe0':  # Arrow keys on Windows
+            key = msvcrt.getch()
+            if key == b'H':  # Up arrow
+                return 'up'
+            elif key == b'P':  # Down arrow
+                return 'down'
+        elif key == b'\r':  # Enter
+            return 'enter'
+        elif key == b'\x1b':  # Escape
+            return 'escape'
+        else:
+            return key.decode('utf-8', errors='ignore')
+    else:  # Unix/Linux/Mac
+        import termios, tty
+        fd = sys.stdin.fileno()
+        old_settings = termios.tcgetattr(fd)
+        try:
+            tty.setraw(sys.stdin.fileno())
+            key = sys.stdin.read(1)
+            if key == '\x1b':  # Escape sequence
+                key += sys.stdin.read(2)
+                if key == '\x1b[A':  # Up arrow
+                    return 'up'
+                elif key == '\x1b[B':  # Down arrow
+                    return 'down'
+                else:
+                    return 'escape'
+            elif key == '\r' or key == '\n':  # Enter
+                return 'enter'
+            else:
+                return key
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+
+def interactive_menu(title, options, subtitle=""):
+    """Display an interactive menu with keyboard navigation."""
+    selected = 0
+    
+    while True:
+        clear_screen()
+        print_banner()
+        print_menu_header(title, subtitle)
+        
+        # Display options
+        for i, option in enumerate(options):
+            print_choice(i + 1, option['label'], selected == i)
+        
+        print_navigation_help()
+        
+        # Get user input
+        key = get_key()
+        
+        if key == 'up':
+            selected = (selected - 1) % len(options)
+        elif key == 'down':
+            selected = (selected + 1) % len(options)
+        elif key == 'enter':
+            animate_loading(f"Selecting {options[selected]['label']}")
+            return options[selected]['value']
+        elif key == 'escape':
+            print(f"\n{Fore.YELLOW}👋 Goodbye!{Style.RESET_ALL}")
+            sys.exit(0)
+        elif key.isdigit():
+            # Allow direct number selection
+            num = int(key) - 1
+            if 0 <= num < len(options):
+                selected = num
+
+def get_project_type():
+    """Ask user to choose between frontend or backend project."""
+    options = [
+        {'label': '🔧 Backend (API Server)', 'value': 'backend'},
+        {'label': '🎨 Frontend (Client Application)', 'value': 'frontend'}
+    ]
+    return interactive_menu("PROJECT TYPE SELECTION", options, "Choose your project architecture")
+
+def get_backend_technology():
+    """Ask user to choose backend technology."""
+    options = [
+        {'label': '🐍 Django REST Framework (Python)', 'value': 'django'},
+        {'label': '🐘 Laravel (PHP) - Coming Soon!', 'value': 'laravel'}
+    ]
+    result = interactive_menu("BACKEND TECHNOLOGY", options, "Select your backend framework")
+    
+    if result == 'laravel':
+        print_warning("Laravel support is coming soon! Using Django for now.")
+        return 'django'
+    return result
+
+def get_frontend_technology():
+    """Ask user to choose frontend technology."""
+    options = [
+        {'label': '🌐 Next.js (TypeScript + SEO Optimized)', 'value': 'nextjs'},
+        {'label': '📱 Flutter (Dart + Cross-Platform)', 'value': 'flutter'},
+        {'label': '⚛️  React Admin Dashboard (TypeScript + Vite)', 'value': 'react-admin'},
+        {'label': '⚛️  React (TypeScript + Vite)', 'value': 'react'},
+        {'label': '🅰️  Angular (TypeScript) - Coming Soon!', 'value': 'angular'},
+        {'label': '💚 Vue.js (TypeScript) - Coming Soon!', 'value': 'vue'}
+    ]
+    result = interactive_menu("FRONTEND TECHNOLOGY", options, "Select your frontend framework")
+    
+    if result in ['angular', 'vue']:
+        print_warning(f"{result.title()} support is coming soon! Using React for now.")
+        return 'react'
+    return result
+
+def get_project_name():
+    """Get project name with enhanced input."""
+    clear_screen()
+    print_banner()
+    print_welcome_message()
+    print_menu_header("PROJECT SETUP", "Enter your project details")
+    
+    print(f"\n{Fore.CYAN}📝 Project Name:{Style.RESET_ALL}")
+    print(f"   {Fore.WHITE}• Use lowercase letters, numbers, and underscores{Style.RESET_ALL}")
+    print(f"   {Fore.WHITE}• Type '.' to use current directory name{Style.RESET_ALL}")
+    
+    project_name = print_question("Enter your project name: ").strip()
+    if not project_name:
+        print_error("Project name cannot be empty!")
+        time.sleep(2)
+        return get_project_name()
+    
+    return project_name
+
+def get_project_path(project_name, use_current_dir=False):
+    """Get project path with enhanced input."""
+    if use_current_dir:
+        return os.path.dirname(os.getcwd())
+    
+    clear_screen()
+    print_banner()
+    print_menu_header("PROJECT LOCATION", "Choose where to create your project")
+    
+    current_dir = os.getcwd()
+    print(f"\n{Fore.CYAN}📁 Current Directory:{Style.RESET_ALL}")
+    print(f"   {Fore.WHITE}{current_dir}{Style.RESET_ALL}")
+    
+    options = [
+        {'label': f'📂 Use current directory ({current_dir})', 'value': 'current'},
+        {'label': '📁 Choose custom path', 'value': 'custom'}
+    ]
+    
+    choice = interactive_menu("PROJECT LOCATION", options, "Where should we create your project?")
+    
+    if choice == 'current':
+        return current_dir
+    else:
+        custom_path = print_question(f"Enter custom path (default: {current_dir}): ").strip()
+        return custom_path if custom_path else current_dir
+
+def show_project_summary(project_name, project_type, technology, project_path):
+    """Show project configuration summary."""
+    clear_screen()
+    print_banner()
+    print_menu_header("PROJECT SUMMARY", "Review your configuration")
+    
+    print(f"\n{Fore.GREEN}✨ Project Configuration:{Style.RESET_ALL}")
+    print(f"   {Fore.CYAN}📛 Name:{Style.RESET_ALL}       {Fore.WHITE}{project_name}{Style.RESET_ALL}")
+    print(f"   {Fore.CYAN}🏗️  Type:{Style.RESET_ALL}       {Fore.WHITE}{project_type.title()}{Style.RESET_ALL}")
+    print(f"   {Fore.CYAN}🔧 Technology:{Style.RESET_ALL}  {Fore.WHITE}{technology.title()}{Style.RESET_ALL}")
+    print(f"   {Fore.CYAN}📁 Path:{Style.RESET_ALL}       {Fore.WHITE}{project_path}{Style.RESET_ALL}")
+    
+    options = [
+        {'label': '🚀 Create Project', 'value': 'create'},
+        {'label': '🔄 Start Over', 'value': 'restart'},
+        {'label': '❌ Cancel', 'value': 'cancel'}
+    ]
+    
+    return interactive_menu("CONFIRM CREATION", options, "Ready to create your project?")
+
+def interactive_init(preset_project_type=None, preset_technology=None):
+    """Interactive project initialization with enhanced UI."""
+    while True:
+        # Get project name
+        project_name = get_project_name()
+        
+        # Handle '.' as current directory shorthand
+        use_current_dir = False
+        if project_name == ".":
+            current_dir = os.getcwd()
+            project_name = os.path.basename(current_dir)
+            use_current_dir = True
+            animate_loading(f"Using current directory name: '{project_name}'")
+        
+        # Get project type
+        if preset_project_type:
+            project_type = preset_project_type
+        else:
+            project_type = get_project_type()
+        
+        # Get technology based on project type
+        if preset_technology:
+            technology = preset_technology
+        else:
+            if project_type == "backend":
+                technology = get_backend_technology()
+            else:
+                technology = get_frontend_technology()
+        
+        # Get project path
+        project_path = get_project_path(project_name, use_current_dir)
+        
+        # Show summary and get confirmation
+        action = show_project_summary(project_name, project_type, technology, project_path)
+        
+        if action == 'create':
+            break
+        elif action == 'restart':
+            continue
+        else:  # cancel
+            print(f"\n{Fore.YELLOW}👋 Project creation cancelled. Goodbye!{Style.RESET_ALL}")
+            sys.exit(0)
+    
+    # Create the project with enhanced feedback
+    animate_loading("Initializing project structure")
+    
+    # Determine final project location
+    if use_current_dir:
+        final_project_path = os.getcwd()
+    else:
+        final_project_path = os.path.join(project_path, project_name)
+    
+    # Initialize project with enhanced feedback
+    clear_screen()
+    print_banner()
+    print_menu_header("CREATING PROJECT", f"Setting up {project_name}")
+    
+    print(f"\n{Fore.GREEN}🚀 Initializing {project_type} project with {technology}...{Style.RESET_ALL}")
+    
+    # Execute project creation first (to create requirements.txt)
+    try:
+        if technology == "django":
+            if use_current_dir:
+                init_drf_project_in_current_dir(project_name)
+            else:
+                init_drf_project(project_path, project_name)
+                
+            # Now show animated dependency installation with real requirements.txt
+            requirements_path = os.path.join(final_project_path, "requirements.txt")
+            if os.path.exists(requirements_path):
+                animate_dependency_install(requirements_path)
+        elif technology == "react":
+            if use_current_dir:
+                init_react_project_in_current_dir(project_name)
+            else:
+                init_react_project(project_path, project_name)
+        elif technology == "react-admin":
+            if use_current_dir:
+                init_react_admin_project_in_current_dir(project_name)
+            else:
+                init_react_admin_project(project_path, project_name)
+        elif technology == "nextjs":
+            if use_current_dir:
+                init_nextjs_project_in_current_dir(project_name)
+            else:
+                init_nextjs_project(project_path, project_name)
+        elif technology == "flutter":
+            if use_current_dir:
+                init_flutter_project_in_current_dir(project_name)
+            else:
+                init_flutter_project(project_path, project_name)
+        else:
+            print_error(f"Technology '{technology}' is not yet implemented!")
+            sys.exit(1)
+        
+        # Ask about authentication app for Django projects
+        if technology == "django":
+            if ask_for_auth_app():
+                create_authentication_app(final_project_path, project_name)
+        
+        # Success screen
+        show_success_screen(project_name, project_type, technology, final_project_path)
+        
+    except Exception as e:
+        print_error(f"Project creation failed: {str(e)}")
+        sys.exit(1)
+
+def ask_for_auth_app():
+    """Ask user if they want to create an authentication app."""
+    clear_screen()
+    print_banner()
+    print_menu_header("AUTHENTICATION SETUP", "Add a dedicated authentication app?")
+    
+    print(f"\n{Fore.CYAN}🔐 Authentication App Features:{Style.RESET_ALL}")
+    print(f"   {Fore.WHITE}• Custom User model with AbstractUser{Style.RESET_ALL}")
+    print(f"   {Fore.WHITE}• JWT Authentication (login, register, refresh){Style.RESET_ALL}")
+    print(f"   {Fore.WHITE}• Profile management (me, update-profile){Style.RESET_ALL}")
+    print(f"   {Fore.WHITE}• Password management (change, reset){Style.RESET_ALL}")
+    print(f"   {Fore.WHITE}• Ready-to-use serializers and views{Style.RESET_ALL}")
+    
+    options = [
+        {'label': '✅ Yes, create authentication app', 'value': True},
+        {'label': '❌ No, skip authentication setup', 'value': False}
+    ]
+    
+    return interactive_menu("AUTHENTICATION CHOICE", options, "Would you like to add authentication?")
+
+def create_authentication_app(project_path, project_name):
+    """Create a complete authentication app with User model, serializers, and views."""
+    animate_loading("Creating authentication app", 1.0)
+    
+    # Create authentication app directory inside apps/
+    auth_app_path = os.path.join(project_path, "apps", "authentication")
+    os.makedirs(auth_app_path, exist_ok=True)
+    
+    # Create __init__.py
+    with open(os.path.join(auth_app_path, "__init__.py"), "w") as f:
+        f.write("")
+    
+    # Copy template files from auth_app templates directory
+    template_dir = os.path.join(os.path.dirname(__file__), "templates", "auth_app")
+    
+    template_files = {
+        'apps.py': 'apps.py',
+        'models.py': 'models.py',
+        'serializers.py': 'serializers.py',
+        'views.py': 'views.py',
+        'urls.py': 'urls.py',
+        'admin.py': 'admin.py',
+    }
+    
+    created_files = []
+    for dest_file, template_file in template_files.items():
+        template_path = os.path.join(template_dir, template_file)
+        if os.path.exists(template_path):
+            with open(template_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            dest_path = os.path.join(auth_app_path, dest_file)
+            with open(dest_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+            created_files.append(dest_file)
+        else:
+            print_error(f"Template file not found: {template_path}")
+    
+    # Update main project settings and URLs
+    update_project_for_auth(project_path, project_name)
+    
+    animate_loading("Authentication app created successfully", 1.0)
+    
+    # Print confirmation that persists through screen clears
+    print_success(f"Authentication app created at: apps/authentication/")
+    print_info(f"Files created: {', '.join(created_files)}")
+    print_info(f"Settings updated: INSTALLED_APPS + 'apps.authentication'")
+    print_info(f"URLs updated: path('auth/', include('apps.authentication.urls'))")
+
+def update_project_for_auth(project_path, project_name):
+    """Update main project settings and URLs to include authentication app."""
+    # Update settings/base.py (generated projects use settings/base.py, not settings.py)
+    settings_path = os.path.join(project_path, project_name, "settings", "base.py")
+    if os.path.exists(settings_path):
+        with open(settings_path, "r") as f:
+            settings_content = f.read()
+        
+        # Add authentication app to INSTALLED_APPS
+        if "'apps.authentication'," not in settings_content:
+            settings_content = settings_content.replace(
+                "INSTALLED_APPS = [",
+                "INSTALLED_APPS = [\n    'apps.authentication',"
+            )
+        
+        # Add AUTH_USER_MODEL setting
+        if "AUTH_USER_MODEL" not in settings_content:
+            settings_content += "\n\n# Custom User Model\nAUTH_USER_MODEL = 'apps.authentication.User'\n"
+        
+        # Add email settings placeholder
+        if "EMAIL_BACKEND" not in settings_content:
+            settings_content += """
+# Email Settings (configure for production)
+EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
+DEFAULT_FROM_EMAIL = 'noreply@yourproject.com'
+FRONTEND_URL = 'http://localhost:3000'  # Update with your frontend URL
+"""
+        
+        with open(settings_path, "w") as f:
+            f.write(settings_content)
+    
+    # Update main URLs
+    main_urls_path = os.path.join(project_path, project_name, "urls.py")
+    if os.path.exists(main_urls_path):
+        with open(main_urls_path, "r") as f:
+            urls_content = f.read()
+        
+        # Add authentication URLs
+        if "path('auth/', include('apps.authentication.urls'))," not in urls_content:
+            # Add include import if not present
+            if "from django.urls import path, include" not in urls_content:
+                urls_content = urls_content.replace(
+                    "from django.urls import path",
+                    "from django.urls import path, include"
+                )
+            
+            # Add auth URL pattern
+            urls_content = urls_content.replace(
+                "urlpatterns = [",
+                "urlpatterns = [\n    path('auth/', include('apps.authentication.urls')),"
+            )
+        
+        with open(main_urls_path, "w") as f:
+            f.write(urls_content)
+
+def show_success_screen(project_name, project_type, technology, project_path):
+    """Show project creation success screen."""
+    clear_screen()
+    
+    # Special success banner
+    print(f"\n{Fore.GREEN}{'▄' * 80}{Style.RESET_ALL}")
+    print(f"{Fore.GREEN}{'█' * 80}{Style.RESET_ALL}")
+    print(f"{Fore.GREEN}█{' ' * 78}█{Style.RESET_ALL}")
+    print(f"{Fore.GREEN}█{' ' * 25}🎉 PROJECT CREATED! 🎉{' ' * 26}█{Style.RESET_ALL}")
+    print(f"{Fore.GREEN}█{' ' * 78}█{Style.RESET_ALL}")
+    print(f"{Fore.GREEN}█{' ' * 15}{Fore.WHITE}🚀 {project_name} is ready for development! 🚀{' ' * 15}{Fore.GREEN}█{Style.RESET_ALL}")
+    print(f"{Fore.GREEN}█{' ' * 78}█{Style.RESET_ALL}")
+    print(f"{Fore.GREEN}{'█' * 80}{Style.RESET_ALL}")
+    print(f"{Fore.GREEN}{'▀' * 80}{Style.RESET_ALL}")
+    print()
+    
+    # Check if authentication app was created
+    auth_app_exists = os.path.exists(os.path.join(project_path, "apps", "authentication"))
+    
+    # Project details
+    print(f"\n{Fore.CYAN}📋 Project Details:{Style.RESET_ALL}")
+    print(f"   {Fore.WHITE}📛 Name: {Fore.YELLOW}{project_name}{Style.RESET_ALL}")
+    print(f"   {Fore.WHITE}🏗️  Type: {Fore.YELLOW}{project_type.title()}{Style.RESET_ALL}")
+    print(f"   {Fore.WHITE}🔧 Tech: {Fore.YELLOW}{technology.title()}{Style.RESET_ALL}")
+    print(f"   {Fore.WHITE}📁 Path: {Fore.YELLOW}{project_path}{Style.RESET_ALL}")
+    if auth_app_exists:
+        print(f"   {Fore.WHITE}🔐 Auth: {Fore.GREEN}✅ Authentication app included{Style.RESET_ALL}")
+    
+    # Next steps
+    print(f"\n{Fore.MAGENTA}🚀 Next Steps:{Style.RESET_ALL}")
+    if technology == "django":
+        print(f"   {Fore.GREEN}1.{Style.RESET_ALL} {Fore.WHITE}cd {project_name}{Style.RESET_ALL}")
+        print(f"   {Fore.GREEN}2.{Style.RESET_ALL} {Fore.WHITE}python manage.py runserver{Style.RESET_ALL}")
+        print(f"   {Fore.GREEN}3.{Style.RESET_ALL} {Fore.WHITE}Visit http://127.0.0.1:8000/docs/ for API docs{Style.RESET_ALL}")
+        print(f"   {Fore.GREEN}4.{Style.RESET_ALL} {Fore.WHITE}Use 'ntc create app <name>' to add new apps{Style.RESET_ALL}")
+    elif technology == "nextjs":
+        print(f"   {Fore.GREEN}1.{Style.RESET_ALL} {Fore.WHITE}cd {project_name}{Style.RESET_ALL}")
+        print(f"   {Fore.GREEN}2.{Style.RESET_ALL} {Fore.WHITE}npm install{Style.RESET_ALL}")
+        print(f"   {Fore.GREEN}3.{Style.RESET_ALL} {Fore.WHITE}npm run dev{Style.RESET_ALL}")
+        print(f"   {Fore.GREEN}4.{Style.RESET_ALL} {Fore.WHITE}Visit http://localhost:3000{Style.RESET_ALL}")
+    elif technology == "react":
+        print(f"   {Fore.GREEN}1.{Style.RESET_ALL} {Fore.WHITE}cd {project_name}{Style.RESET_ALL}")
+        print(f"   {Fore.GREEN}2.{Style.RESET_ALL} {Fore.WHITE}npm install{Style.RESET_ALL}")
+        print(f"   {Fore.GREEN}3.{Style.RESET_ALL} {Fore.WHITE}npm run dev{Style.RESET_ALL}")
+        print(f"   {Fore.GREEN}4.{Style.RESET_ALL} {Fore.WHITE}Visit http://localhost:5173{Style.RESET_ALL}")
+    elif technology == "react-admin":
+        print(f"   {Fore.GREEN}1.{Style.RESET_ALL} {Fore.WHITE}cd {project_name}{Style.RESET_ALL}")
+        print(f"   {Fore.GREEN}2.{Style.RESET_ALL} {Fore.WHITE}npm install{Style.RESET_ALL}")
+        print(f"   {Fore.GREEN}3.{Style.RESET_ALL} {Fore.WHITE}npm run dev{Style.RESET_ALL}")
+        print(f"   {Fore.GREEN}4.{Style.RESET_ALL} {Fore.WHITE}Visit http://localhost:5173{Style.RESET_ALL}")
+    elif technology == "flutter":
+        print(f"   {Fore.GREEN}1.{Style.RESET_ALL} {Fore.WHITE}cd {project_name}{Style.RESET_ALL}")
+        print(f"   {Fore.GREEN}2.{Style.RESET_ALL} {Fore.WHITE}flutter pub get{Style.RESET_ALL}")
+        print(f"   {Fore.GREEN}3.{Style.RESET_ALL} {Fore.WHITE}flutter run{Style.RESET_ALL}")
+        print(f"   {Fore.GREEN}4.{Style.RESET_ALL} {Fore.WHITE}App will run on connected device/emulator{Style.RESET_ALL}")
+    
+    # Additional resources
+    print(f"\n{Fore.BLUE}📚 Resources:{Style.RESET_ALL}")
+    print(f"   {Fore.WHITE}• Check the README.md for detailed setup instructions{Style.RESET_ALL}")
+    print(f"   {Fore.WHITE}• Explore the .knowledge/ directory for AI documentation{Style.RESET_ALL}")
+    print(f"   {Fore.WHITE}• Use 'ntc --help' for more commands{Style.RESET_ALL}")
+    
+    print(f"\n{Fore.YELLOW}Happy coding! 🚀{Style.RESET_ALL}")
+    
+    # Wait for user acknowledgment
+    print(f"\n{Fore.CYAN}Press any key to exit...{Style.RESET_ALL}")
+    get_key()
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="NTC - Nexent Toolkit Console",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  ntc init                      # Interactive mode with all options
+  ntc init --technology django  # Quick Django project
+  ntc init --technology react   # Quick React project
+  ntc init --technology nextjs  # Quick Next.js project
+  ntc init --technology flutter # Quick Flutter project
+  ntc init --frontend react     # Choose React frontend, ask for backend
+  ntc compose myproject         # Compose full-stack project with multiple components
+  ntc start                     # Start all services from ntc.yml configuration
+  ntc create app myapp          # Create new Django app with NTC structure
+  ntc drf init path name        # Legacy Django REST Framework initialization
+        """
+    )
+    
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    
+    # Enhanced init command
+    init_parser = subparsers.add_parser("init", help="Interactive project initialization")
+    init_parser.add_argument('--technology', '-t', type=str, 
+                        choices=['django', 'react', 'react-admin', 'nextjs', 'flutter'],
+                        help='Technology to use (django, react, react-admin, nextjs, flutter)')
+    init_parser.add_argument("--backend", 
+                           choices=["django", "drf", "laravel"],
+                           help="Backend technology")
+    init_parser.add_argument("--frontend", 
+                           choices=["react", "react-admin", "nextjs", "flutter"],
+                           help="Frontend technology")
+    
+    # Create command for apps
+    create_parser = subparsers.add_parser("create", help="Create new components")
+    create_subparsers = create_parser.add_subparsers(dest="create_type", help="Type of component to create")
+    
+    # Create app subcommand
+    app_parser = create_subparsers.add_parser("app", help="Create new Django app with NTC structure")
+    app_parser.add_argument("app_name", help="Name of the app to create")
+    
+    # Legacy DRF command for backward compatibility
+    drf_parser = subparsers.add_parser("drf", help="Django REST Framework commands (legacy)")
+    drf_subparsers = drf_parser.add_subparsers(dest="drf_action")
+    drf_init_parser = drf_subparsers.add_parser("init", help="Initialize DRF project")
+    drf_init_parser.add_argument("path", help="Base path to create the project")
+    drf_init_parser.add_argument("name", help="Project name")
+    
+    # Composer command for full-stack project composition
+    composer_parser = subparsers.add_parser("compose", help="Compose a full-stack project with multiple components")
+    composer_parser.add_argument("project_name", help="Name of the project")
+    composer_parser.add_argument("--path", help="Base path to create the project (default: current directory)")
+    
+    # Start services command
+    start_parser = subparsers.add_parser("start", help="Start all services defined in ntc.yml")
+    start_parser.add_argument("--path", help="Path to project root directory (default: current directory)")
+    
+    args = parser.parse_args()
+    
+    if args.command == "init":
+        # Determine project type and technology from arguments
+        project_type = None
+        technology = None
+        ask_for_other = False
+        
+        if args.technology:
+            # Direct technology specified - skip both project type and technology selection
+            if args.technology in ["django", "drf", "laravel"]:
+                project_type = "backend"
+                technology = "django" if args.technology == "drf" else args.technology
+            else:  # react, react-admin, next, vue
+                project_type = "frontend"
+                technology = args.technology
+        elif args.backend:
+            # Backend specified, but we still need to ask what kind of backend
+            project_type = "backend"
+            if args.backend == "drf":
+                technology = "django"
+            else:
+                technology = args.backend
+        elif args.frontend:
+            # Frontend specified, but we still need to ask what kind of frontend
+            project_type = "frontend"
+            technology = args.frontend
+        
+        # Call enhanced interactive init with pre-selected options
+        interactive_init(preset_project_type=project_type, preset_technology=technology)
+    elif args.command == "create" and args.create_type == "app":
+        create_app_structure(args.app_name)
+    elif args.command == "drf" and args.drf_action == "init":
+        # Legacy support
+        init_drf_project(args.path, args.name)
+    elif args.command == "compose":
+        # Composer for full-stack project composition
+        if args.path:
+            compose_project(args.project_name, args.path)
+        else:
+            compose_project(args.project_name)
+    elif args.command == "start":
+        # Start services from ntc.yml configuration
+        if args.path:
+            start_services(args.path)
+        else:
+            start_services()
+    else:
+        # Show help if no command provided
+        print_banner()
+        print(f"{Fore.CYAN}💡 Quick Start:{Style.RESET_ALL}")
+        print(f"   {Fore.WHITE}• Run {Fore.GREEN}'ntc init'{Style.RESET_ALL} {Fore.WHITE}for interactive setup{Style.RESET_ALL}")
+        print(f"   {Fore.WHITE}• Run {Fore.GREEN}'ntc init django'{Style.RESET_ALL} {Fore.WHITE}for Django project{Style.RESET_ALL}")
+        print(f"   {Fore.WHITE}• Run {Fore.GREEN}'ntc init react-admin'{Style.RESET_ALL} {Fore.WHITE}for React Admin Dashboard{Style.RESET_ALL}")
+        print(f"   {Fore.WHITE}• Run {Fore.GREEN}'ntc compose myproject'{Style.RESET_ALL} {Fore.WHITE}for full-stack composition{Style.RESET_ALL}")
+        print(f"   {Fore.WHITE}• Run {Fore.GREEN}'ntc start'{Style.RESET_ALL} {Fore.WHITE}to start all services{Style.RESET_ALL}")
+        print(f"   {Fore.WHITE}• Run {Fore.GREEN}'ntc create app <name>'{Style.RESET_ALL} {Fore.WHITE}to add Django apps{Style.RESET_ALL}")
+        print()
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()