Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

CMD.bash

@@ -0,0 +1,14 @@
+# Install required packages
+pip install -r requirements.txt
+
+# For video conversion, install FFmpeg
+# Ubuntu/Debian:
+sudo apt-get install ffmpeg
+
+# macOS:
+brew install ffmpeg
+
+# Windows: Download from ffmpeg.org
+winget install Gyan-FFmpeg
+# Run the application
+python main.py

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bahadur Ali
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,54 @@
+---
+title: AI File Converter Pro
+emoji: 🔄
+colorFrom: blue
+colorTo: green
+sdk: python
+sdk_version: 3.10
+app_file: main.py
+pinned: false
+license: mit
+tags:
+- file-converter
+- ai
+- pyqt6
+- document-converter
+- image-converter
+- video-converter
+- audio-converter
+- ocr
+---
+
+# AI File Converter Pro
+
+An intelligent, AI-powered file converter that supports documents, images, videos, and audio files with smart enhancement capabilities.
+
+## 🚀 Features
+
+- **Multi-Format Support**: Convert between 20+ file formats
+  - Documents: PDF, DOCX, TXT, HTML, MD
+  - Images: PNG, JPG, WebP, BMP, TIFF
+  - Videos: MP4, AVI, MKV, MOV, WebM
+  - Audio: MP3, WAV, OGG, M4A, FLAC
+
+- **AI-Powered Features**
+  - Smart format recommendations
+  - Automatic quality optimization
+  - Image enhancement (contrast, sharpness)
+  - Audio normalization
+  - OCR text extraction from images/PDFs
+
+![Banner](https://i.ytimg.com/vi/3_U5T2Qg5_o/hq720.jpg?sqp=-oaymwEhCK4FEIIDSFryq4qpAxMIARUAAAAAGAElAADIQj0AgKJD&rs=AOn4CLA_ciOfAAWCyJTzbW4iKMSAlqFkBA.png)
+
+- **User-Friendly Interface**
+  - Drag & drop support
+  - Batch processing
+  - Real-time progress tracking
+  - Built-in AI assistant for help
+
+## 📋 Requirements
+
+```bash
+Python 3.8+
+FFmpeg (for video/audio conversion)
+Tesseract OCR (optional, for text extraction)

ai/ai_assistant.py

@@ -0,0 +1,378 @@
+import re
+import os
+import subprocess
+from pathlib import Path
+from typing import Dict, Any, Tuple, Optional
+
+
+class AIAssistant:
+    def __init__(self):
+        self.knowledge_base = self.load_knowledge_base()
+
+    def load_knowledge_base(self):
+        return {
+            "document": {
+                "pdf": {
+                    "best_for": "Official documents, forms, print-ready files",
+                    "suggested_formats": {
+                        "word": "For editing documents",
+                        "txt": "For text extraction",
+                        "html": "For web display"
+                    }
+                },
+                "word": {
+                    "best_for": "Editable documents, reports, letters",
+                    "suggested_formats": {
+                        "pdf": "For sharing without edits",
+                        "txt": "For plain text",
+                        "html": "For web publishing"
+                    }
+                },
+                "txt": {
+                    "best_for": "Simple text, code, notes",
+                    "suggested_formats": {
+                        "pdf": "For professional sharing",
+                        "docx": "For formatted documents",
+                        "md": "For documentation"
+                    }
+                }
+            },
+            "image": {
+                "jpg": {
+                    "best_for": "Photographs, web images",
+                    "suggested_formats": {
+                        "png": "For images with transparency",
+                        "webp": "For better web compression",
+                        "bmp": "For uncompressed quality"
+                    }
+                },
+                "png": {
+                    "best_for": "Graphics, logos, screenshots with transparency",
+                    "suggested_formats": {
+                        "jpg": "For smaller file size (photos)",
+                        "webp": "For web optimization",
+                        "ico": "For icons"
+                    }
+                },
+                "webp": {
+                    "best_for": "Web images, modern browsers",
+                    "suggested_formats": {
+                        "png": "For editing",
+                        "jpg": "For compatibility"
+                    }
+                }
+            },
+            "video": {
+                "mp4": {
+                    "best_for": "Universal compatibility, web, social media",
+                    "suggested_formats": {
+                        "gif": "For short animations",
+                        "avi": "For editing",
+                        "mkv": "For high quality storage"
+                    }
+                },
+                "avi": {
+                    "best_for": "Editing, Windows compatibility",
+                    "suggested_formats": {
+                        "mp4": "For web sharing",
+                        "mkv": "For compression"
+                    }
+                }
+            },
+            "audio": {
+                "mp3": {
+                    "best_for": "Music, podcasts, universal playback",
+                    "suggested_formats": {
+                        "wav": "For editing",
+                        "flac": "For lossless quality",
+                        "ogg": "For open source projects"
+                    }
+                },
+                "wav": {
+                    "best_for": "Professional audio, editing",
+                    "suggested_formats": {
+                        "mp3": "For smaller size",
+                        "flac": "For lossless compression"
+                    }
+                }
+            }
+        }
+
+    def ask(self, question: str, context: Dict[str, Any]) -> str:
+        """Process AI queries and provide intelligent responses"""
+        question_lower = question.lower()
+
+        # Check for conversion commands
+        if self.is_conversion_command(question_lower):
+            return self.execute_conversion_command(question, context)
+
+        # Check for format suggestions
+        elif "suggest" in question_lower or "recommend" in question_lower or "best format" in question_lower:
+            return self.suggest_format(question_lower, context)
+
+        # Check for file analysis
+        elif "what is this" in question_lower or "analyze" in question_lower:
+            return self.analyze_file(context)
+
+        # Check for general help
+        elif "help" in question_lower or "how to" in question_lower:
+            return self.get_help(question_lower, context)
+
+        # Default response
+        else:
+            return self.get_general_response(question_lower, context)
+
+    def is_conversion_command(self, text: str) -> bool:
+        """Check if user wants to convert a file"""
+        commands = ['convert', 'change', 'transform', 'turn into', 'make it']
+        return any(cmd in text for cmd in commands)
+
+    def parse_conversion_request(self, text: str, context: Dict[str, Any]) -> Tuple[Optional[str], Optional[str]]:
+        """Parse natural language conversion request"""
+        # Pattern: "convert this to pdf" or "change this file to mp3"
+        patterns = [
+            r'(?:convert|change|transform|turn)\s+(?:this|it|the\s+file)\s+(?:to|into)\s+(\w+)',
+            r'to\s+(\w+)\s+format',
+            r'convert\s+to\s+(\w+)',
+        ]
+
+        for pattern in patterns:
+            match = re.search(pattern, text.lower())
+            if match:
+                target_format = match.group(1)
+                return target_format, None
+
+        return None, None
+
+    def execute_conversion_command(self, question: str, context: Dict[str, Any]) -> str:
+        """Execute a conversion command"""
+        target_format, _ = self.parse_conversion_request(question, context)
+
+        if not target_format:
+            return self.get_conversion_help()
+
+        # Get current context
+        current_type = context.get("file_type", "").lower()
+        current_format = context.get("output_format", "").lower()
+
+        if not current_type or not current_format:
+            return "⚠️ Please select a file type and output format first in the settings panel."
+
+        response = f"🎯 **Conversion Command Received**\n\n"
+        response += f"Converting from **{current_format.upper()}** to **{target_format.upper()}**...\n\n"
+
+        # Check if format is supported
+        supported_formats = {
+            "document": ["pdf", "docx", "txt", "html", "md"],
+            "image": ["jpg", "png", "webp", "bmp", "tiff"],
+            "video": ["mp4", "avi", "mkv", "mov", "webm", "gif"],
+            "audio": ["mp3", "wav", "ogg", "m4a", "flac"]
+        }
+
+        if current_type in supported_formats and target_format in supported_formats[current_type]:
+            response += f"✅ **{target_format.upper()}** is supported!\n\n"
+            response += f"💡 **Tip**: Make sure you've added files to convert, then click 'Start Conversion'\n\n"
+
+            # Add format-specific advice
+            advice = self.get_format_advice(current_type, target_format)
+            if advice:
+                response += f"📌 **Advice**: {advice}\n\n"
+        else:
+            response += f"❌ **{target_format.upper()}** is not supported for {current_type} files.\n\n"
+            response += f"Supported formats: {', '.join(supported_formats.get(current_type, []))}\n\n"
+
+        response += "🔄 **Next Steps**:\n"
+        response += "1. Select the target format from the dropdown\n"
+        response += "2. Add files to convert\n"
+        response += "3. Click 'Start Conversion'"
+
+        return response
+
+    def suggest_format(self, question: str, context: Dict[str, Any]) -> str:
+        """Suggest best format based on use case"""
+        current_type = context.get("file_type", "").lower()
+
+        # Determine use case
+        use_case = ""
+        if "web" in question or "website" in question:
+            use_case = "web"
+        elif "email" in question:
+            use_case = "email"
+        elif "print" in question:
+            use_case = "print"
+        elif "edit" in question or "editing" in question:
+            use_case = "edit"
+        elif "compress" in question or "small" in question:
+            use_case = "compress"
+        elif "quality" in question or "lossless" in question:
+            use_case = "quality"
+
+        # Format suggestions by use case and type
+        suggestions = {
+            "document": {
+                "web": "HTML or PDF (for consistent formatting)",
+                "email": "PDF (preserves formatting) or TXT (small size)",
+                "print": "PDF (best for printing)",
+                "edit": "DOCX (Microsoft Word) or ODT (OpenOffice)",
+                "compress": "TXT (smallest) or compressed PDF",
+                "quality": "PDF (preserves all formatting)"
+            },
+            "image": {
+                "web": "WebP (best compression) or JPEG (good quality)",
+                "email": "JPEG (small size) or PNG (if transparency needed)",
+                "print": "TIFF (high quality) or PNG",
+                "edit": "PNG (lossless) or PSD",
+                "compress": "JPEG (80% quality) or WebP",
+                "quality": "PNG or TIFF (lossless)"
+            },
+            "video": {
+                "web": "MP4 with H.264 codec (best compatibility)",
+                "email": "GIF (short clips) or small MP4",
+                "print": "Not applicable for video",
+                "edit": "AVI or MOV (uncompressed)",
+                "compress": "MP4 with H.265 codec (smallest)",
+                "quality": "MKV or MOV (ProRes)"
+            },
+            "audio": {
+                "web": "MP3 (128-192kbps) or OGG",
+                "email": "MP3 (low bitrate)",
+                "print": "Not applicable for audio",
+                "edit": "WAV or FLAC (lossless)",
+                "compress": "MP3 or AAC",
+                "quality": "FLAC or WAV (lossless)"
+            }
+        }
+
+        if current_type in suggestions:
+            if use_case in suggestions[current_type]:
+                recommended = suggestions[current_type][use_case]
+                response = f"📋 **Format Recommendation**\n\n"
+                response += f"Based on your request to **{use_case}** a {current_type}:\n"
+                response += f"✅ Recommended format: **{recommended}**\n\n"
+
+                # Add additional tips
+                tips = {
+                    "web": f"💡 For web, also consider optimizing file size and using responsive formats.",
+                    "email": f"💡 Keep file size under 10-20MB for email attachments.",
+                    "print": f"💡 Use at least 300 DPI for print quality.",
+                    "edit": f"💡 Lossless formats preserve quality for multiple edits.",
+                    "compress": f"💡 Balance between quality and file size.",
+                    "quality": f"💡 Lossless formats preserve original quality."
+                }
+                if use_case in tips:
+                    response += f"{tips[use_case]}\n\n"
+
+                response += f"🔄 To convert: Select **{recommended.split()[0]}** from the Output Format dropdown."
+                return response
+
+        # Default suggestions
+        default_suggestions = {
+            "document": "PDF for sharing, DOCX for editing, TXT for simplicity",
+            "image": "JPEG for photos, PNG for graphics, WebP for web",
+            "video": "MP4 for compatibility, AVI for editing, MKV for storage",
+            "audio": "MP3 for general use, WAV for editing, FLAC for quality"
+        }
+
+        response = f"💡 **Format Suggestions for {current_type.title()}s:**\n\n"
+        response += f"{default_suggestions.get(current_type, 'Choose based on your needs')}\n\n"
+        response += f"Tell me more about your use case (web, print, edit, compress) for better recommendations!"
+
+        return response
+
+    def analyze_file(self, context: Dict[str, Any]) -> str:
+        """Analyze file and provide insights"""
+        current_type = context.get("file_type", "").lower()
+        current_format = context.get("output_format", "").upper()
+
+        response = f"🔍 **File Analysis**\n\n"
+        response += f"📄 Type: {current_type.title()}\n"
+        response += f"🎯 Current format: {current_format}\n"
+
+        if current_type in self.knowledge_base and current_format.lower() in self.knowledge_base[current_type]:
+            info = self.knowledge_base[current_type][current_format.lower()]
+            response += f"📌 Best for: {info['best_for']}\n\n"
+
+            if "suggested_formats" in info:
+                response += f"🔄 **Suggested conversions:**\n"
+                for fmt, reason in info['suggested_formats'].items():
+                    response += f"  • {fmt.upper()} - {reason}\n"
+        else:
+            response += f"\n💡 Try converting to a different format for better results!\n"
+
+        return response
+
+    def get_help(self, question: str, context: Dict[str, Any]) -> str:
+        """Get help on specific topics"""
+        response = "🤖 **How I Can Help You**\n\n"
+        response += "I can assist with:\n"
+        response += "✅ **Convert files** - Say: 'convert this to mp4' or 'make it PDF'\n"
+        response += "✅ **Suggest formats** - Ask: 'what's the best format for web?'\n"
+        response += "✅ **Analyze files** - Ask: 'analyze this file' or 'what is this good for?'\n"
+        response += "✅ **Optimize settings** - Ask: 'how to compress video?'\n\n"
+        response += "💬 **Examples:**\n"
+        response += "• 'Convert this to PNG'\n"
+        response += "• 'Best format for email attachment'\n"
+        response += "• 'How to reduce file size?'\n"
+        response += "• 'What format should I use for web?'"
+
+        return response
+
+    def get_general_response(self, question: str, context: Dict[str, Any]) -> str:
+        """General response when no specific command is detected"""
+        response = "🤖 **AI Assistant Ready**\n\n"
+
+        # Try to understand intent
+        if "thank" in question:
+            return "You're welcome! 😊 Let me know if you need help with any conversions!"
+
+        if "hello" in question or "hi" in question:
+            return "Hello! 👋 I'm your AI conversion assistant. How can I help you today?\n\nTry asking me to 'convert this to PDF' or 'suggest best format for web'!"
+
+        response += "I can help you:\n"
+        response += "• **Convert files** using natural language\n"
+        response += "• **Recommend formats** based on your needs\n"
+        response += "• **Analyze files** and suggest improvements\n"
+        response += "• **Optimize** quality vs file size\n\n"
+        response += "💡 **Quick commands:**\n"
+        response += "  → 'Convert this to MP3'\n"
+        response += "  → 'Best format for web'\n"
+        response += "  → 'How to compress video?'\n"
+        response += "  → 'Analyze this file'"
+
+        return response
+
+    def get_format_advice(self, file_type: str, target_format: str) -> str:
+        """Get specific advice for format conversion"""
+        advice = {
+            ("image", "jpg"): "Good for photos. Use quality 85-90 for best balance.",
+            ("image", "png"): "Best for graphics with transparency. Larger file size.",
+            ("image", "webp"): "Modern format with great compression. Supported by all modern browsers.",
+            ("video", "mp4"): "Most compatible. H.264 codec is universal.",
+            ("video", "gif"): "Good for short animations. Keep duration under 5 seconds.",
+            ("audio", "mp3"): "Universal format. 192kbps is good for most uses.",
+            ("audio", "flac"): "Lossless format. Perfect for archiving.",
+            ("document", "pdf"): "Preserves formatting across all devices.",
+            ("document", "txt"): "Plain text - very small but loses all formatting."
+        }
+
+        return advice.get((file_type, target_format), "")
+
+    def get_conversion_help(self) -> str:
+        """Help for conversion commands"""
+        return """
+🎯 **Conversion Commands**
+
+Try these examples:
+• "**Convert this to PDF**" - Changes output format to PDF
+• "**Make it MP3**" - Changes to audio format
+• "**Transform to PNG**" - Changes image format
+• "**Change this to AVI**" - Changes video format
+
+**How to use:**
+1. Select the file type (Document/Image/Video/Audio)
+2. Say what format you want
+3. Click "Ask AI" or press Enter
+4. Then click "Start Conversion"
+
+💡 **Tip:** Be specific about the format you want!
+"""

converters/audio_converter.py

@@ -0,0 +1,99 @@
+import os
+from pathlib import Path
+from typing import Callable, Dict, Any
+import traceback
+
+# Setup ffmpeg for pydub
+import shutil
+
+ffmpeg_path = shutil.which('ffmpeg') or shutil.which('ffmpeg.exe')
+if ffmpeg_path:
+    os.environ["FFMPEG_BINARY"] = ffmpeg_path
+
+try:
+    from pydub import AudioSegment
+
+    PYDUB_AVAILABLE = True
+except ImportError:
+    PYDUB_AVAILABLE = False
+    print("pydub not installed. Audio conversion will not work.")
+
+
+class AudioConverter:
+    def __init__(self):
+        pass
+
+    def convert(self, input_path: str, output_path: str,
+                options: Dict[str, Any], progress_callback: Callable = None) -> bool:
+        """Convert audio files"""
+        try:
+            if not PYDUB_AVAILABLE:
+                print("pydub library not available")
+                return False
+
+            self._update_progress(progress_callback, 10)
+
+            # Check if input file exists
+            if not os.path.exists(input_path):
+                print(f"Input file not found: {input_path}")
+                return False
+
+            # Load audio
+            audio = AudioSegment.from_file(input_path)
+
+            self._update_progress(progress_callback, 40)
+
+            # Apply AI enhancement if requested
+            if options.get("ai_enhancement", False):
+                audio = self.enhance_audio(audio)
+
+            self._update_progress(progress_callback, 60)
+
+            # Get quality settings
+            quality_settings = options.get("quality_settings", {})
+            bitrate = quality_settings.get("audio", "192k")
+
+            # Create output directory
+            Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+
+            # Export to desired format
+            output_ext = Path(output_path).suffix.lower()
+
+            export_params = {
+                '.mp3': {'format': 'mp3', 'bitrate': bitrate},
+                '.wav': {'format': 'wav'},
+                '.ogg': {'format': 'ogg', 'bitrate': bitrate},
+                '.m4a': {'format': 'mp4', 'bitrate': bitrate},
+                '.flac': {'format': 'flac'}
+            }
+
+            if output_ext in export_params:
+                audio.export(output_path, **export_params[output_ext])
+            else:
+                audio.export(output_path)
+
+            self._update_progress(progress_callback, 100)
+
+            print(f"✓ Successfully converted: {os.path.basename(input_path)} → {output_ext}")
+            return True
+
+        except Exception as e:
+            print(f"Audio conversion error for {input_path}: {str(e)}")
+            traceback.print_exc()
+            return False
+
+    def _update_progress(self, callback, value):
+        """Safely update progress"""
+        if callback is not None:
+            try:
+                callback(value)
+            except Exception:
+                pass
+
+    def enhance_audio(self, audio):
+        """Basic audio enhancement"""
+        try:
+            audio = audio.normalize()
+            return audio
+        except:
+            return audio

converters/document_converter.py

@@ -0,0 +1,382 @@
+import os
+from pathlib import Path
+from typing import Callable, Dict, Any
+import traceback
+
+# Optional imports with error handling
+try:
+    from docx import Document
+
+    DOCX_AVAILABLE = True
+except ImportError:
+    DOCX_AVAILABLE = False
+    print("⚠ python-docx not installed. DOCX conversion will not work.")
+
+try:
+    import fitz  # PyMuPDF
+
+    FITZ_AVAILABLE = True
+except ImportError:
+    FITZ_AVAILABLE = False
+    print("⚠ PyMuPDF not installed. PDF conversion will not work.")
+
+try:
+    import markdown
+
+    MARKDOWN_AVAILABLE = True
+except ImportError:
+    MARKDOWN_AVAILABLE = False
+    print("⚠ markdown not installed. MD conversion will not work.")
+
+try:
+    from bs4 import BeautifulSoup
+
+    BS4_AVAILABLE = True
+except ImportError:
+    BS4_AVAILABLE = False
+    print("⚠ beautifulsoup4 not installed. HTML conversion will not work.")
+
+
+class DocumentConverter:
+    def __init__(self):
+        pass
+
+    def convert(self, input_path: str, output_path: str,
+                options: Dict[str, Any], progress_callback: Callable = None) -> bool:
+        """Convert document files"""
+        input_ext = Path(input_path).suffix.lower()
+
+        try:
+            self._update_progress(progress_callback, 10)
+
+            # Check if input file exists
+            if not os.path.exists(input_path):
+                print(f"Input file not found: {input_path}")
+                return False
+
+            # Create output directory if needed
+            Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+
+            result = False
+
+            # PDF conversion
+            if input_ext == '.pdf':
+                if not FITZ_AVAILABLE:
+                    print("PyMuPDF not available for PDF conversion")
+                    return False
+                result = self.convert_pdf(input_path, output_path, options, progress_callback)
+
+            # DOCX conversion
+            elif input_ext in ['.docx', '.doc']:
+                if not DOCX_AVAILABLE:
+                    print("python-docx not available for DOCX conversion")
+                    return False
+                result = self.convert_docx(input_path, output_path, options, progress_callback)
+
+            # TXT conversion
+            elif input_ext == '.txt':
+                result = self.convert_txt(input_path, output_path, options, progress_callback)
+
+            # Markdown conversion
+            elif input_ext == '.md':
+                if not MARKDOWN_AVAILABLE:
+                    print("markdown library not available")
+                    return False
+                result = self.convert_markdown(input_path, output_path, options, progress_callback)
+
+            # HTML conversion
+            elif input_ext == '.html':
+                result = self.convert_html(input_path, output_path, options, progress_callback)
+
+            else:
+                result = self.convert_generic(input_path, output_path, options, progress_callback)
+
+            if result:
+                output_ext = Path(output_path).suffix.lower()
+                print(f"✓ Successfully converted: {os.path.basename(input_path)} → {output_ext}")
+
+            return result
+
+        except Exception as e:
+            print(f"Document conversion error for {input_path}: {str(e)}")
+            traceback.print_exc()
+            return False
+
+    def _update_progress(self, callback, value):
+        """Safely update progress"""
+        if callback is not None:
+            try:
+                callback(value)
+            except Exception:
+                pass
+
+    def convert_pdf(self, input_path: str, output_path: str,
+                    options: Dict[str, Any], progress_callback: Callable = None) -> bool:
+        """Convert PDF to other formats"""
+        try:
+            doc = fitz.open(input_path)
+            total_pages = len(doc)
+
+            self._update_progress(progress_callback, 20)
+
+            if output_path.endswith('.txt'):
+                text = ""
+                for page_num in range(total_pages):
+                    page = doc[page_num]
+                    text += page.get_text()
+                    progress_pct = 20 + (page_num + 1) * 60 // total_pages
+                    self._update_progress(progress_callback, progress_pct)
+
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    f.write(text)
+
+            elif output_path.endswith('.docx'):
+                docx_doc = Document()
+                for page_num in range(total_pages):
+                    page = doc[page_num]
+                    text = page.get_text()
+                    docx_doc.add_paragraph(text)
+                    progress_pct = 20 + (page_num + 1) * 60 // total_pages
+                    self._update_progress(progress_callback, progress_pct)
+
+                docx_doc.save(output_path)
+
+            elif output_path.endswith('.html'):
+                html_content = """<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>PDF Content</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 40px; }
+        .page { margin-bottom: 30px; page-break-after: always; }
+        .page-number { color: #666; font-size: 12px; margin-bottom: 10px; }
+        pre { white-space: pre-wrap; word-wrap: break-word; }
+    </style>
+</head>
+<body>
+"""
+                for page_num in range(total_pages):
+                    page = doc[page_num]
+                    text = page.get_text()
+                    html_content += f"""
+<div class="page">
+    <div class="page-number">Page {page_num + 1}</div>
+    <pre>{text}</pre>
+</div>
+"""
+                    progress_pct = 20 + (page_num + 1) * 60 // total_pages
+                    self._update_progress(progress_callback, progress_pct)
+
+                html_content += "</body></html>"
+
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    f.write(html_content)
+
+            doc.close()
+            self._update_progress(progress_callback, 100)
+            return True
+
+        except Exception as e:
+            print(f"PDF conversion error: {e}")
+            return False
+
+    def convert_docx(self, input_path: str, output_path: str,
+                     options: Dict[str, Any], progress_callback: Callable = None) -> bool:
+        """Convert DOCX to other formats"""
+        try:
+            doc = Document(input_path)
+            self._update_progress(progress_callback, 30)
+
+            if output_path.endswith('.txt'):
+                text = "\n".join([para.text for para in doc.paragraphs])
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    f.write(text)
+
+            elif output_path.endswith('.html'):
+                html_content = """<!DOCTYPE html>
+<html>
+<head><meta charset="UTF-8"><title>Document Content</title></head>
+<body>
+"""
+                for para in doc.paragraphs:
+                    if para.text.strip():
+                        html_content += f"<p>{para.text}</p>"
+                html_content += "</body></html>"
+
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    f.write(html_content)
+
+            elif output_path.endswith('.md'):
+                markdown_content = "\n\n".join([para.text for para in doc.paragraphs if para.text.strip()])
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    f.write(markdown_content)
+
+            elif output_path.endswith('.pdf'):
+                # Simple PDF conversion using text extraction
+                text = "\n".join([para.text for para in doc.paragraphs])
+                with open(output_path.replace('.pdf', '.txt'), 'w', encoding='utf-8') as f:
+                    f.write(text)
+                print("Note: DOCX to PDF requires additional libraries. Saved as TXT instead.")
+
+            self._update_progress(progress_callback, 100)
+            return True
+
+        except Exception as e:
+            print(f"DOCX conversion error: {e}")
+            return False
+
+    def convert_txt(self, input_path: str, output_path: str,
+                    options: Dict[str, Any], progress_callback: Callable = None) -> bool:
+        """Convert TXT to other formats"""
+        try:
+            with open(input_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+
+            self._update_progress(progress_callback, 40)
+
+            if output_path.endswith('.md'):
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    f.write(content)
+
+            elif output_path.endswith('.html'):
+                html_content = f"""<!DOCTYPE html>
+<html>
+<head><meta charset="UTF-8"><title>Text Document</title></head>
+<body>
+<pre>{content}</pre>
+</body></html>"""
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    f.write(html_content)
+
+            elif output_path.endswith('.docx'):
+                if DOCX_AVAILABLE:
+                    doc = Document()
+                    doc.add_paragraph(content)
+                    doc.save(output_path)
+                else:
+                    with open(output_path.replace('.docx', '.txt'), 'w', encoding='utf-8') as f:
+                        f.write(content)
+                    print("Note: python-docx not installed. Saved as TXT instead.")
+
+            self._update_progress(progress_callback, 100)
+            return True
+
+        except Exception as e:
+            print(f"TXT conversion error: {e}")
+            return False
+
+    def convert_markdown(self, input_path: str, output_path: str,
+                         options: Dict[str, Any], progress_callback: Callable = None) -> bool:
+        """Convert Markdown to other formats"""
+        try:
+            with open(input_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+
+            self._update_progress(progress_callback, 40)
+
+            if output_path.endswith('.html'):
+                html_content = markdown.markdown(content)
+                full_html = f"""<!DOCTYPE html>
+<html>
+<head><meta charset="UTF-8"><title>Markdown Document</title></head>
+<body>
+{html_content}
+</body></html>"""
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    f.write(full_html)
+
+            elif output_path.endswith('.docx'):
+                if DOCX_AVAILABLE and BS4_AVAILABLE:
+                    html = markdown.markdown(content)
+                    soup = BeautifulSoup(html, 'html.parser')
+                    doc = Document()
+                    for para in soup.find_all('p'):
+                        if para.get_text().strip():
+                            doc.add_paragraph(para.get_text())
+                    doc.save(output_path)
+                else:
+                    with open(output_path.replace('.docx', '.txt'), 'w', encoding='utf-8') as f:
+                        f.write(content)
+                    print("Note: Required libraries not installed. Saved as TXT instead.")
+
+            self._update_progress(progress_callback, 100)
+            return True
+
+        except Exception as e:
+            print(f"Markdown conversion error: {e}")
+            return False
+
+    def convert_html(self, input_path: str, output_path: str,
+                     options: Dict[str, Any], progress_callback: Callable = None) -> bool:
+        """Convert HTML to other formats"""
+        try:
+            with open(input_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+
+            self._update_progress(progress_callback, 40)
+
+            if BS4_AVAILABLE:
+                soup = BeautifulSoup(content, 'html.parser')
+                text = soup.get_text()
+            else:
+                # Simple text extraction
+                import re
+                text = re.sub(r'<[^>]+>', ' ', content)
+                text = re.sub(r'\s+', ' ', text).strip()
+
+            if output_path.endswith('.txt'):
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    f.write(text)
+
+            elif output_path.endswith('.md'):
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    f.write(f"# Converted from HTML\n\n{text}")
+
+            elif output_path.endswith('.docx'):
+                if DOCX_AVAILABLE:
+                    doc = Document()
+                    doc.add_paragraph(text)
+                    doc.save(output_path)
+                else:
+                    with open(output_path.replace('.docx', '.txt'), 'w', encoding='utf-8') as f:
+                        f.write(text)
+
+            self._update_progress(progress_callback, 100)
+            return True
+
+        except Exception as e:
+            print(f"HTML conversion error: {e}")
+            return False
+
+    def convert_generic(self, input_path: str, output_path: str,
+                        options: Dict[str, Any], progress_callback: Callable = None) -> bool:
+        """Generic text file conversion"""
+        try:
+            # Try to read as text
+            encodings = ['utf-8', 'latin-1', 'cp1252']
+            content = None
+
+            for encoding in encodings:
+                try:
+                    with open(input_path, 'r', encoding=encoding) as f:
+                        content = f.read()
+                    break
+                except UnicodeDecodeError:
+                    continue
+
+            if content is None:
+                # If can't read as text, just copy binary
+                with open(input_path, 'rb') as src:
+                    with open(output_path, 'wb') as dst:
+                        dst.write(src.read())
+            else:
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    f.write(content)
+
+            self._update_progress(progress_callback, 100)
+            return True
+
+        except Exception as e:
+            print(f"Generic conversion error: {e}")
+            return False

converters/image_converter.py

@@ -0,0 +1,105 @@
+from PIL import Image
+from pathlib import Path
+from typing import Callable, Dict, Any
+import traceback
+import os
+
+
+class ImageConverter:
+    def __init__(self):
+        pass
+
+    def convert(self, input_path: str, output_path: str,
+                options: Dict[str, Any], progress_callback: Callable = None) -> bool:
+        """Convert image files"""
+        try:
+            # Update progress safely
+            self._update_progress(progress_callback, 10)
+
+            # Check if input file exists
+            if not os.path.exists(input_path):
+                print(f"Input file not found: {input_path}")
+                return False
+
+            # Open image
+            img = Image.open(input_path)
+
+            self._update_progress(progress_callback, 30)
+
+            # Apply AI enhancement if requested
+            if options.get("ai_enhancement", False):
+                img = self.enhance_image(img)
+
+            self._update_progress(progress_callback, 50)
+
+            # Get quality settings
+            quality_settings = options.get("quality_settings", {})
+            quality = quality_settings.get("image", 85)
+
+            # Create output directory if needed
+            Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+
+            # Convert and save based on output format
+            output_ext = Path(output_path).suffix.lower()
+
+            self._update_progress(progress_callback, 70)
+
+            # Handle different formats
+            if output_ext in ['.jpg', '.jpeg']:
+                # Convert RGBA to RGB for JPEG
+                if img.mode in ('RGBA', 'P'):
+                    img = img.convert('RGB')
+                img.save(output_path, 'JPEG', quality=quality, optimize=True)
+
+            elif output_ext == '.png':
+                # PNG uses compression level (0-9)
+                compression = 6 if quality < 90 else 3
+                img.save(output_path, 'PNG', compress_level=compression, optimize=True)
+
+            elif output_ext == '.webp':
+                img.save(output_path, 'WEBP', quality=quality, method=6)
+
+            elif output_ext == '.bmp':
+                img.save(output_path, 'BMP')
+
+            elif output_ext == '.tiff':
+                img.save(output_path, 'TIFF', compression='tiff_lzw')
+
+            else:
+                img.save(output_path)
+
+            self._update_progress(progress_callback, 100)
+
+            print(f"✓ Successfully converted: {os.path.basename(input_path)} → {output_ext}")
+            return True
+
+        except Exception as e:
+            print(f"Image conversion error for {input_path}: {str(e)}")
+            traceback.print_exc()
+            return False
+
+    def _update_progress(self, callback, value):
+        """Safely update progress"""
+        if callback is not None:
+            try:
+                callback(value)
+            except Exception as e:
+                # If callback fails (e.g., Qt signal issue), just continue
+                pass
+
+    def enhance_image(self, img):
+        """Basic image enhancement"""
+        try:
+            from PIL import ImageEnhance, ImageFilter
+
+            # Enhance contrast slightly
+            enhancer = ImageEnhance.Contrast(img)
+            img = enhancer.enhance(1.1)
+
+            # Enhance sharpness
+            enhancer = ImageEnhance.Sharpness(img)
+            img = enhancer.enhance(1.05)
+
+            return img
+        except:
+            return img

converters/video_converter.py

@@ -0,0 +1,102 @@
+import subprocess
+import os
+from pathlib import Path
+from typing import Callable, Dict, Any
+import shutil
+import traceback
+
+# Find ffmpeg
+ffmpeg_path = shutil.which('ffmpeg') or shutil.which('ffmpeg.exe')
+if not ffmpeg_path:
+    common_paths = [
+        r"C:\ffmpeg\bin\ffmpeg.exe",
+        r"C:\Program Files\ffmpeg\bin\ffmpeg.exe",
+    ]
+    for path in common_paths:
+        if os.path.exists(path):
+            ffmpeg_path = path
+            break
+
+
+class VideoConverter:
+    def __init__(self):
+        self.ffmpeg_available = self._check_ffmpeg()
+
+    def _check_ffmpeg(self):
+        """Check if ffmpeg is installed"""
+        if not ffmpeg_path or not os.path.exists(ffmpeg_path):
+            print("⚠ FFmpeg not found. Video conversion will not work.")
+            return False
+        return True
+
+    def convert(self, input_path: str, output_path: str,
+                options: Dict[str, Any], progress_callback: Callable = None) -> bool:
+        """Convert video files using ffmpeg"""
+        try:
+            if not self.ffmpeg_available:
+                print("FFmpeg not available for video conversion")
+                return False
+
+            self._update_progress(progress_callback, 10)
+
+            # Check input file
+            if not os.path.exists(input_path):
+                print(f"Input file not found: {input_path}")
+                return False
+
+            # Build ffmpeg command
+            cmd = [ffmpeg_path, '-i', input_path, '-y']
+
+            # Add quality settings
+            quality_settings = options.get("quality_settings", {})
+            crf_value = quality_settings.get("video", "23")
+
+            # Output format specific settings
+            output_ext = Path(output_path).suffix.lower()
+
+            format_settings = {
+                '.mp4': ['-c:v', 'libx264', '-preset', 'medium', '-crf', crf_value, '-c:a', 'aac', '-b:a', '128k'],
+                '.avi': ['-c:v', 'libxvid', '-q:v', '4', '-c:a', 'mp3', '-b:a', '192k'],
+                '.mkv': ['-c:v', 'libx264', '-crf', crf_value, '-c:a', 'aac'],
+                '.mov': ['-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-c:a', 'aac'],
+                '.webm': ['-c:v', 'libvpx-vp9', '-crf', crf_value, '-b:v', '0', '-c:a', 'libopus'],
+                '.gif': ['-vf', 'fps=10,scale=320:-1:flags=lanczos', '-c:v', 'gif']
+            }
+
+            if output_ext in format_settings:
+                cmd.extend(format_settings[output_ext])
+
+            # Add AI enhancement
+            if options.get("ai_enhancement", False):
+                cmd.extend(['-vf', 'unsharp=5:5:1.0:5:5:0.0'])
+
+            # Create output directory
+            Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+            cmd.append(output_path)
+
+            self._update_progress(progress_callback, 50)
+
+            # Run ffmpeg
+            result = subprocess.run(cmd, capture_output=True, text=True)
+
+            self._update_progress(progress_callback, 100)
+
+            if result.returncode == 0:
+                print(f"✓ Successfully converted: {os.path.basename(input_path)} → {output_ext}")
+                return True
+            else:
+                print(f"FFmpeg error: {result.stderr[:200]}")
+                return False
+
+        except Exception as e:
+            print(f"Video conversion error for {input_path}: {str(e)}")
+            traceback.print_exc()
+            return False
+
+    def _update_progress(self, callback, value):
+        """Safely update progress"""
+        if callback is not None:
+            try:
+                callback(value)
+            except Exception:
+                pass

main.py

@@ -0,0 +1,792 @@
+import sys
+import os
+import json
+import threading
+import shutil
+from pathlib import Path
+from datetime import datetime
+from PyQt6.QtWidgets import (
+    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
+    QPushButton, QLabel, QFileDialog, QComboBox, QProgressBar,
+    QTextEdit, QTabWidget, QGroupBox, QGridLayout, QMessageBox,
+    QListWidget, QListWidgetItem, QCheckBox, QSpinBox, QLineEdit,
+    QSplitter, QFrame, QToolButton, QSizePolicy
+)
+from PyQt6.QtCore import Qt, QThread, pyqtSignal, QSize, QPropertyAnimation, QEasingCurve, QRect
+from PyQt6.QtGui import QFont, QIcon, QDragEnterEvent, QDropEvent, QPalette, QColor, QAction
+
+# Fix FFmpeg before any imports
+import warnings
+
+warnings.filterwarnings("ignore", message="Couldn't find ffmpeg or avconv")
+
+# Setup FFmpeg
+ffmpeg_path = None
+for path in [
+    shutil.which('ffmpeg'),
+    shutil.which('ffmpeg.exe'),
+    r"C:\ffmpeg\bin\ffmpeg.exe",
+    r"C:\Program Files\ffmpeg\bin\ffmpeg.exe"
+]:
+    if path and os.path.exists(path):
+        ffmpeg_path = path
+        os.environ["FFMPEG_BINARY"] = ffmpeg_path
+        break
+
+# Import converters
+from converters.document_converter import DocumentConverter
+from converters.image_converter import ImageConverter
+from converters.video_converter import VideoConverter
+from converters.audio_converter import AudioConverter
+from ai.ai_assistant import AIAssistant
+
+
+class ConversionThread(QThread):
+    progress_update = pyqtSignal(int)
+    status_update = pyqtSignal(str)
+    conversion_complete = pyqtSignal(bool, str)
+
+    def __init__(self, converter, input_path, output_path, options=None):
+        super().__init__()
+        self.converter = converter
+        self.input_path = input_path
+        self.output_path = output_path
+        self.options = options or {}
+
+    def run(self):
+        try:
+            self.status_update.emit(f"Converting: {os.path.basename(self.input_path)}")
+            success = self.converter.convert(
+                self.input_path,
+                self.output_path,
+                self.options,
+                self.progress_update
+            )
+
+            if success:
+                self.conversion_complete.emit(True, f"✅ Successfully converted: {os.path.basename(self.input_path)}")
+            else:
+                self.conversion_complete.emit(False, f"❌ Failed to convert: {os.path.basename(self.input_path)}")
+        except Exception as e:
+            self.conversion_complete.emit(False, f"❌ Error: {str(e)}")
+
+
+class CollapsibleSidebar(QWidget):
+    """Collapsible sidebar widget"""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setVisible(True)
+        self.animation_duration = 300
+
+    def toggle(self):
+        """Toggle sidebar visibility with animation"""
+        self.animated_toggle()
+
+    def animated_toggle(self):
+        """Animated toggle of sidebar"""
+        if self.isVisible():
+            self.animation = QPropertyAnimation(self, b"maximumWidth")
+            self.animation.setDuration(self.animation_duration)
+            self.animation.setStartValue(self.width())
+            self.animation.setEndValue(0)
+            self.animation.setEasingCurve(QEasingCurve.Type.InOutQuad)
+            self.animation.finished.connect(lambda: self.setVisible(False))
+            self.animation.start()
+        else:
+            self.setVisible(True)
+            self.animation = QPropertyAnimation(self, b"maximumWidth")
+            self.animation.setDuration(self.animation_duration)
+            self.animation.setStartValue(0)
+            self.animation.setEndValue(400)  # Fixed width when expanded
+            self.animation.setEasingCurve(QEasingCurve.Type.InOutQuad)
+            self.animation.start()
+
+
+class FileConverterApp(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("🎯 AI File Converter Pro")
+        self.setGeometry(100, 100, 1400, 900)
+
+        # Sidebar state
+        self.sidebar_visible = True
+
+        # Set modern style
+        self.setStyleSheet("""
+            QMainWindow {
+                background-color: #1e1e2e;
+            }
+            QGroupBox {
+                font-weight: bold;
+                border: 2px solid #313244;
+                border-radius: 8px;
+                margin-top: 10px;
+                padding-top: 10px;
+                color: #cdd6f4;
+                font-size: 13px;
+            }
+            QGroupBox::title {
+                subcontrol-origin: margin;
+                left: 10px;
+                padding: 0 5px 0 5px;
+                color: #89b4fa;
+            }
+            QPushButton {
+                background-color: #89b4fa;
+                border: none;
+                padding: 8px;
+                border-radius: 6px;
+                font-weight: bold;
+                color: #1e1e2e;
+            }
+            QPushButton:hover {
+                background-color: #b4befe;
+            }
+            QPushButton:pressed {
+                background-color: #6c7086;
+            }
+            QToolButton {
+                background-color: #313244;
+                border: 1px solid #45475a;
+                border-radius: 6px;
+                padding: 8px;
+                color: #cdd6f4;
+            }
+            QToolButton:hover {
+                background-color: #45475a;
+            }
+            QListWidget, QTextEdit, QLineEdit, QComboBox {
+                background-color: #313244;
+                border: 1px solid #45475a;
+                border-radius: 6px;
+                padding: 5px;
+                color: #cdd6f4;
+            }
+            QProgressBar {
+                border: 2px solid #45475a;
+                border-radius: 6px;
+                text-align: center;
+                color: #cdd6f4;
+            }
+            QProgressBar::chunk {
+                background-color: #89b4fa;
+                border-radius: 4px;
+            }
+            QTabWidget::pane {
+                background-color: #1e1e2e;
+                border: 1px solid #313244;
+                border-radius: 6px;
+            }
+            QTabBar::tab {
+                background-color: #313244;
+                padding: 8px;
+                margin: 2px;
+                border-radius: 4px;
+                color: #cdd6f4;
+            }
+            QTabBar::tab:selected {
+                background-color: #89b4fa;
+                color: #1e1e2e;
+            }
+            QLabel {
+                color: #cdd6f4;
+            }
+            QCheckBox {
+                color: #cdd6f4;
+            }
+            QSplitter::handle {
+                background-color: #313244;
+                margin: 2px;
+            }
+            QSplitter::handle:hover {
+                background-color: #89b4fa;
+            }
+        """)
+
+        # Initialize converters
+        self.doc_converter = DocumentConverter()
+        self.img_converter = ImageConverter()
+        self.video_converter = VideoConverter()
+        self.audio_converter = AudioConverter()
+        self.ai_assistant = AIAssistant()
+
+        # Conversion queue
+        self.conversion_queue = []
+        self.current_conversion = None
+        self.active_threads = []
+        self.converted_count = 0
+        self.failed_count = 0
+
+        self.setup_ui()
+        self.setup_drag_drop()
+        self.setup_menu_bar()
+
+    def setup_menu_bar(self):
+        """Setup menu bar with toggle option"""
+        menubar = self.menuBar()
+        menubar.setStyleSheet("""
+            QMenuBar {
+                background-color: #1e1e2e;
+                color: #cdd6f4;
+                border-bottom: 1px solid #313244;
+            }
+            QMenuBar::item:selected {
+                background-color: #313244;
+            }
+            QMenu {
+                background-color: #1e1e2e;
+                color: #cdd6f4;
+                border: 1px solid #313244;
+            }
+            QMenu::item:selected {
+                background-color: #89b4fa;
+                color: #1e1e2e;
+            }
+        """)
+
+        view_menu = menubar.addMenu("👁️ View")
+
+        toggle_action = QAction("🤖 Toggle AI Assistant", self)
+        toggle_action.setShortcut("Ctrl+Shift+A")
+        toggle_action.triggered.connect(self.toggle_sidebar)
+        view_menu.addAction(toggle_action)
+
+        # Add separator and other options
+        view_menu.addSeparator()
+
+        reset_view_action = QAction("🔄 Reset Layout", self)
+        reset_view_action.setShortcut("Ctrl+Shift+R")
+        reset_view_action.triggered.connect(self.reset_layout)
+        view_menu.addAction(reset_view_action)
+
+    def setup_ui(self):
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        main_layout = QHBoxLayout(central_widget)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.setSpacing(0)
+
+        # Create splitter for resizable panels
+        self.main_splitter = QSplitter(Qt.Orientation.Horizontal)
+
+        # Left panel - Main content
+        self.left_panel = self.create_left_panel()
+        self.main_splitter.addWidget(self.left_panel)
+
+        # Right panel - AI Sidebar (collapsible)
+        self.sidebar_widget = self.create_sidebar()
+        self.main_splitter.addWidget(self.sidebar_widget)
+
+        # Set initial sizes (70% left, 30% right)
+        self.main_splitter.setSizes([980, 420])
+
+        main_layout.addWidget(self.main_splitter)
+
+    def create_left_panel(self):
+        """Create the main left panel with file list and controls"""
+        left_panel = QWidget()
+        left_layout = QVBoxLayout(left_panel)
+        left_layout.setSpacing(10)
+        left_layout.setContentsMargins(10, 10, 10, 10)
+
+        # File selection area
+        file_group = QGroupBox("📁 Files to Convert")
+        file_layout = QVBoxLayout()
+
+        self.file_list = QListWidget()
+        self.file_list.setSelectionMode(QListWidget.SelectionMode.ExtendedSelection)
+        self.file_list.setMinimumHeight(200)
+        file_layout.addWidget(self.file_list)
+
+        btn_layout = QHBoxLayout()
+        add_btn = QPushButton("➕ Add Files")
+        add_btn.clicked.connect(self.add_files)
+        add_folder_btn = QPushButton("📂 Add Folder")
+        add_folder_btn.clicked.connect(self.add_folder)
+        remove_btn = QPushButton("❌ Remove Selected")
+        remove_btn.clicked.connect(self.remove_selected)
+        clear_btn = QPushButton("🗑️ Clear All")
+        clear_btn.clicked.connect(self.clear_files)
+
+        btn_layout.addWidget(add_btn)
+        btn_layout.addWidget(add_folder_btn)
+        btn_layout.addWidget(remove_btn)
+        btn_layout.addWidget(clear_btn)
+        file_layout.addLayout(btn_layout)
+
+        file_group.setLayout(file_layout)
+        left_layout.addWidget(file_group)
+
+        # Converter settings
+        converter_group = QGroupBox("⚙️ Converter Settings")
+        converter_layout = QGridLayout()
+        converter_layout.setSpacing(10)
+
+        converter_layout.addWidget(QLabel("File Type:"), 0, 0)
+        self.file_type_combo = QComboBox()
+        self.file_type_combo.addItems(["Document", "Image", "Video", "Audio"])
+        self.file_type_combo.currentTextChanged.connect(self.on_file_type_changed)
+        converter_layout.addWidget(self.file_type_combo, 0, 1)
+
+        converter_layout.addWidget(QLabel("Output Format:"), 1, 0)
+        self.output_format_combo = QComboBox()
+        converter_layout.addWidget(self.output_format_combo, 1, 1)
+
+        converter_layout.addWidget(QLabel("Quality:"), 2, 0)
+        self.quality_combo = QComboBox()
+        self.quality_combo.addItems(["High", "Medium", "Low"])
+        converter_layout.addWidget(self.quality_combo, 2, 1)
+
+        converter_layout.addWidget(QLabel("Output Folder:"), 3, 0)
+        self.output_folder = QLineEdit()
+        self.output_folder.setText(str(Path.home() / "Downloads" / "Converted"))
+        converter_layout.addWidget(self.output_folder, 3, 1)
+
+        browse_btn = QPushButton("📁 Browse")
+        browse_btn.clicked.connect(self.browse_output_folder)
+        converter_layout.addWidget(browse_btn, 3, 2)
+
+        # Create output folder if not exists
+        Path(self.output_folder.text()).mkdir(parents=True, exist_ok=True)
+
+        self.ai_checkbox = QCheckBox("🤖 Enable AI Enhancement")
+        self.ai_checkbox.setChecked(False)
+        converter_layout.addWidget(self.ai_checkbox, 4, 0, 1, 2)
+
+        converter_group.setLayout(converter_layout)
+        left_layout.addWidget(converter_group)
+
+        # Progress section
+        progress_group = QGroupBox("📊 Conversion Progress")
+        progress_layout = QVBoxLayout()
+
+        self.progress_bar = QProgressBar()
+        progress_layout.addWidget(self.progress_bar)
+
+        self.status_label = QLabel("✅ Ready to convert")
+        self.status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        progress_layout.addWidget(self.status_label)
+
+        self.stats_label = QLabel("📈 Converted: 0 | ❌ Failed: 0")
+        self.stats_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        progress_layout.addWidget(self.stats_label)
+
+        progress_group.setLayout(progress_layout)
+        left_layout.addWidget(progress_group)
+
+        # Convert button
+        self.convert_btn = QPushButton("🚀 Start Conversion")
+        self.convert_btn.setMinimumHeight(50)
+        self.convert_btn.setStyleSheet("""
+            QPushButton {
+                background-color: #a6e3a1;
+                font-size: 16px;
+                font-weight: bold;
+            }
+            QPushButton:hover {
+                background-color: #94e2d5;
+            }
+        """)
+        self.convert_btn.clicked.connect(self.start_conversion)
+        left_layout.addWidget(self.convert_btn)
+
+        return left_panel
+
+    def create_sidebar(self):
+        """Create the collapsible AI sidebar"""
+        sidebar_container = QWidget()
+        sidebar_layout = QVBoxLayout(sidebar_container)
+        sidebar_layout.setContentsMargins(0, 0, 0, 0)
+        sidebar_layout.setSpacing(0)
+
+        # Header with toggle button
+        header = QWidget()
+        header.setStyleSheet("""
+            QWidget {
+                background-color: #313244;
+                border-bottom: 1px solid #45475a;
+            }
+        """)
+        header_layout = QHBoxLayout(header)
+        header_layout.setContentsMargins(10, 10, 10, 10)
+
+        title_label = QLabel("🤖 AI Assistant")
+        title_label.setStyleSheet("font-size: 14px; font-weight: bold; color: #89b4fa;")
+        header_layout.addWidget(title_label)
+
+        header_layout.addStretch()
+
+        # Close button
+        self.close_sidebar_btn = QToolButton()
+        self.close_sidebar_btn.setText("◀")
+        self.close_sidebar_btn.setToolTip("Close Sidebar (Ctrl+Shift+A)")
+        self.close_sidebar_btn.setStyleSheet("""
+            QToolButton {
+                background-color: #45475a;
+                border: none;
+                font-size: 14px;
+                padding: 5px;
+            }
+            QToolButton:hover {
+                background-color: #6c7086;
+            }
+        """)
+        self.close_sidebar_btn.clicked.connect(self.toggle_sidebar)
+        header_layout.addWidget(self.close_sidebar_btn)
+
+        sidebar_layout.addWidget(header)
+
+        # Tab widget for AI and Log
+        right_panel = QTabWidget()
+        right_panel.setStyleSheet("""
+            QTabWidget::pane {
+                border: none;
+            }
+        """)
+
+        # AI Assistant tab
+        ai_widget = QWidget()
+        ai_layout = QVBoxLayout(ai_widget)
+        ai_layout.setSpacing(10)
+
+        # Suggestions panel
+        suggestions_group = QGroupBox("💡 Quick Commands")
+        suggestions_layout = QGridLayout()
+        suggestions_group.setMaximumHeight(220)
+
+        suggestions = [
+            ("🖼️ To PNG", "convert this to png"),
+            ("📄 To PDF", "convert to pdf"),
+            ("🎵 To MP3", "make it mp3"),
+            ("🎬 Web format", "best format for web"),
+            ("📊 Analyze", "analyze this file"),
+            ("💾 Compress", "how to compress video"),
+            ("📧 Email size", "best format for email"),
+            ("🖨️ Print", "best format for printing"),
+        ]
+
+        row, col = 0, 0
+        for text, cmd in suggestions:
+            btn = QPushButton(text)
+            btn.setMaximumHeight(30)
+            btn.clicked.connect(lambda checked, c=cmd: self.ai_input.setText(c))
+            suggestions_layout.addWidget(btn, row, col)
+            col += 1
+            if col >= 2:
+                col = 0
+                row += 1
+
+        suggestions_group.setLayout(suggestions_layout)
+        ai_layout.addWidget(suggestions_group)
+
+        # Input area
+        self.ai_input = QTextEdit()
+        self.ai_input.setPlaceholderText("""💬 Ask me anything about file conversion...
+
+Examples:
+• "Convert this to PNG"
+• "What's the best format for web images?"
+• "How to compress video for email?"
+• "Analyze this file"
+• "Make it smaller without losing quality" """)
+        self.ai_input.setMaximumHeight(100)
+        ai_layout.addWidget(self.ai_input)
+
+        # Buttons
+        ai_buttons_layout = QHBoxLayout()
+        ai_send_btn = QPushButton("💭 Ask AI")
+        ai_send_btn.clicked.connect(self.ask_ai_assistant)
+        ai_clear_btn = QPushButton("🗑️ Clear")
+        ai_clear_btn.clicked.connect(lambda: self.ai_input.clear())
+        ai_buttons_layout.addWidget(ai_send_btn)
+        ai_buttons_layout.addWidget(ai_clear_btn)
+        ai_layout.addLayout(ai_buttons_layout)
+
+        # Response area
+        self.ai_response = QTextEdit()
+        self.ai_response.setReadOnly(True)
+        self.ai_response.setPlaceholderText("AI response will appear here...")
+        self.ai_response.setMinimumHeight(200)
+        ai_layout.addWidget(self.ai_response)
+
+        right_panel.addTab(ai_widget, "💬 Assistant")
+
+        # Log tab
+        log_widget = QWidget()
+        log_layout = QVBoxLayout(log_widget)
+        self.log_text = QTextEdit()
+        self.log_text.setReadOnly(True)
+        log_layout.addWidget(self.log_text)
+
+        log_btn_layout = QHBoxLayout()
+        clear_log_btn = QPushButton("🗑️ Clear Log")
+        clear_log_btn.clicked.connect(lambda: self.log_text.clear())
+        log_btn_layout.addStretch()
+        log_btn_layout.addWidget(clear_log_btn)
+        log_layout.addLayout(log_btn_layout)
+
+        right_panel.addTab(log_widget, "📝 Log")
+
+        sidebar_layout.addWidget(right_panel)
+
+        return sidebar_container
+
+    def toggle_sidebar(self):
+        """Toggle the AI sidebar visibility"""
+        self.sidebar_visible = not self.sidebar_visible
+
+        if self.sidebar_visible:
+            self.sidebar_widget.setVisible(True)
+            self.close_sidebar_btn.setText("◀")
+            self.main_splitter.setSizes([980, 420])
+        else:
+            self.sidebar_widget.setVisible(False)
+            self.close_sidebar_btn.setText("▶")
+            self.main_splitter.setSizes([1400, 0])
+
+        # Update tooltip
+        self.close_sidebar_btn.setToolTip(
+            "Open Sidebar (Ctrl+Shift+A)" if not self.sidebar_visible else "Close Sidebar (Ctrl+Shift+A)")
+
+    def reset_layout(self):
+        """Reset layout to default"""
+        self.main_splitter.setSizes([980, 420])
+        if not self.sidebar_visible:
+            self.toggle_sidebar()
+        self.log_message("🔄 Layout reset to default")
+
+    def setup_drag_drop(self):
+        self.setAcceptDrops(True)
+
+    def dragEnterEvent(self, event: QDragEnterEvent):
+        if event.mimeData().hasUrls():
+            event.acceptProposedAction()
+
+    def dropEvent(self, event: QDropEvent):
+        for url in event.mimeData().urls():
+            file_path = url.toLocalFile()
+            if os.path.isfile(file_path):
+                self.add_file_to_list(file_path)
+
+    def add_files(self):
+        files, _ = QFileDialog.getOpenFileNames(
+            self, "Select Files to Convert", "",
+            "All Files (*.*)"
+        )
+        for file in files:
+            self.add_file_to_list(file)
+
+    def add_folder(self):
+        folder = QFileDialog.getExistingDirectory(self, "Select Folder")
+        if folder:
+            for root, dirs, files in os.walk(folder):
+                for file in files:
+                    self.add_file_to_list(os.path.join(root, file))
+
+    def remove_selected(self):
+        for item in self.file_list.selectedItems():
+            self.file_list.takeItem(self.file_list.row(item))
+
+    def add_file_to_list(self, file_path):
+        # Check if already in list
+        for i in range(self.file_list.count()):
+            if self.file_list.item(i).data(Qt.ItemDataRole.UserRole) == file_path:
+                return
+        item = QListWidgetItem(f"📄 {os.path.basename(file_path)}")
+        item.setToolTip(file_path)
+        item.setData(Qt.ItemDataRole.UserRole, file_path)
+        self.file_list.addItem(item)
+
+    def clear_files(self):
+        self.file_list.clear()
+
+    def on_file_type_changed(self, file_type):
+        self.output_format_combo.clear()
+
+        formats = {
+            "Document": ["pdf", "docx", "txt", "html", "md"],
+            "Image": ["png", "jpg", "webp", "bmp", "tiff"],
+            "Video": ["mp4", "avi", "mkv", "mov", "webm", "gif"],
+            "Audio": ["mp3", "wav", "ogg", "m4a", "flac"]
+        }
+        self.output_format_combo.addItems(formats.get(file_type, []))
+
+    def browse_output_folder(self):
+        folder = QFileDialog.getExistingDirectory(self, "Select Output Folder")
+        if folder:
+            self.output_folder.setText(folder)
+            Path(folder).mkdir(parents=True, exist_ok=True)
+
+    def get_converter(self):
+        file_type = self.file_type_combo.currentText()
+        converters = {
+            "Document": self.doc_converter,
+            "Image": self.img_converter,
+            "Video": self.video_converter,
+            "Audio": self.audio_converter
+        }
+        return converters.get(file_type)
+
+    def start_conversion(self):
+        if self.file_list.count() == 0:
+            QMessageBox.warning(self, "Warning", "Please add files to convert")
+            return
+
+        # Reset stats
+        self.converted_count = 0
+        self.failed_count = 0
+        self.update_stats()
+
+        # Build queue
+        self.conversion_queue = []
+        selected_items = self.file_list.selectedItems()
+        if selected_items:
+            for item in selected_items:
+                self.conversion_queue.append(item.data(Qt.ItemDataRole.UserRole))
+        else:
+            for i in range(self.file_list.count()):
+                self.conversion_queue.append(self.file_list.item(i).data(Qt.ItemDataRole.UserRole))
+
+        self.convert_btn.setEnabled(False)
+        self.process_next_conversion()
+
+    def process_next_conversion(self):
+        if not self.conversion_queue:
+            self.log_message("🎉 All conversions completed!")
+            self.status_label.setText("✅ All conversions completed!")
+            self.progress_bar.setValue(100)
+            self.convert_btn.setEnabled(True)
+            QMessageBox.information(self, "Success",
+                                    f"Conversion complete!\n✅ Success: {self.converted_count}\n❌ Failed: {self.failed_count}")
+            return
+
+        input_path = self.conversion_queue.pop(0)
+        self.current_conversion = input_path
+
+        # Get output path
+        output_format = self.output_format_combo.currentText()
+        output_folder = self.output_folder.text()
+        base_name = Path(input_path).stem
+        output_path = Path(output_folder) / f"{base_name}.{output_format}"
+
+        # Create output directory if needed
+        Path(output_folder).mkdir(parents=True, exist_ok=True)
+
+        # Quality settings
+        quality_map = {
+            "High": {"video": "18", "audio": "320k", "image": 95},
+            "Medium": {"video": "23", "audio": "192k", "image": 85},
+            "Low": {"video": "28", "audio": "128k", "image": 70}
+        }
+        quality = self.quality_combo.currentText()
+
+        # Prepare options
+        options = {
+            "ai_enhancement": self.ai_checkbox.isChecked(),
+            "quality": quality,
+            "quality_settings": quality_map[quality]
+        }
+
+        # Start conversion thread
+        converter = self.get_converter()
+        if converter:
+            self.conversion_thread = ConversionThread(
+                converter, input_path, str(output_path), options
+            )
+            self.conversion_thread.progress_update.connect(self.update_progress)
+            self.conversion_thread.status_update.connect(self.update_status)
+            self.conversion_thread.conversion_complete.connect(self.on_conversion_complete)
+            self.conversion_thread.start()
+            self.active_threads.append(self.conversion_thread)
+        else:
+            self.log_message(f"❌ Invalid converter for: {input_path}")
+            self.process_next_conversion()
+
+    def update_progress(self, value):
+        self.progress_bar.setValue(value)
+
+    def update_status(self, status):
+        self.status_label.setText(status)
+        self.log_message(status)
+
+    def on_conversion_complete(self, success, message):
+        self.log_message(message)
+        if success:
+            self.converted_count += 1
+        else:
+            self.failed_count += 1
+        self.update_stats()
+        self.process_next_conversion()
+
+    def update_stats(self):
+        self.stats_label.setText(f"📈 Converted: {self.converted_count} | ❌ Failed: {self.failed_count}")
+
+    def log_message(self, message):
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        self.log_text.append(f"[{timestamp}] {message}")
+
+    def ask_ai_assistant(self):
+        """Process AI query and potentially auto-configure settings"""
+        question = self.ai_input.toPlainText()
+        if not question.strip():
+            return
+
+        self.ai_response.setPlainText("🤔 AI Assistant is thinking...")
+
+        # Get AI response
+        response = self.ai_assistant.ask(question, self.get_conversion_context())
+
+        # Check if AI suggested a format change
+        suggested_format = self.extract_format_from_response(response)
+        if suggested_format:
+            # Auto-update the output format combo box
+            index = self.output_format_combo.findText(suggested_format.lower())
+            if index >= 0:
+                self.output_format_combo.setCurrentIndex(index)
+                response += f"\n\n✅ **Auto-configured**: Output format changed to {suggested_format.upper()}"
+
+        # Check if AI suggested a file type change
+        suggested_type = self.extract_file_type_from_response(response)
+        if suggested_type:
+            index = self.file_type_combo.findText(suggested_type.title())
+            if index >= 0:
+                self.file_type_combo.setCurrentIndex(index)
+                response += f"\n\n✅ **Auto-configured**: File type changed to {suggested_type.title()}"
+
+        self.ai_response.setPlainText(response)
+
+    def extract_format_from_response(self, response: str) -> str:
+        """Extract suggested format from AI response"""
+        formats = ['pdf', 'docx', 'txt', 'html', 'md', 'png', 'jpg', 'jpeg',
+                   'webp', 'bmp', 'tiff', 'mp4', 'avi', 'mkv', 'mov', 'webm',
+                   'gif', 'mp3', 'wav', 'ogg', 'm4a', 'flac']
+
+        for fmt in formats:
+            if f" {fmt.upper()}" in response.upper() or f"to {fmt}" in response.lower():
+                return fmt
+        return ""
+
+    def extract_file_type_from_response(self, response: str) -> str:
+        """Extract suggested file type from AI response"""
+        types = ['document', 'image', 'video', 'audio']
+        for t in types:
+            if t in response.lower():
+                return t
+        return ""
+
+    def get_conversion_context(self):
+        return {
+            "file_type": self.file_type_combo.currentText(),
+            "output_format": self.output_format_combo.currentText(),
+            "file_count": self.file_list.count(),
+            "ai_enhancement": self.ai_checkbox.isChecked(),
+            "quality": self.quality_combo.currentText()
+        }
+
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    window = FileConverterApp()
+    window.show()
+    sys.exit(app.exec())

requirements.txt

@@ -0,0 +1,10 @@
+PyQt6>=6.5.0
+Pillow>=10.0.0
+python-docx>=0.8.11
+PyMuPDF>=1.23.0
+markdown>=3.4.0
+beautifulsoup4>=4.12.0
+pydub>=0.25.1
+opencv-python>=4.8.0
+pytesseract>=0.3.10
+numpy>=1.24.0