Update ai/ai_assistant.py

ai/ai_assistant.py

@@ -1,378 +1,474 @@
 import re
-import os
-import subprocess
 from pathlib import Path
 from typing import Dict, Any, Tuple, Optional
 
 
 class AIAssistant:
+
+    SUPPORTED_FORMATS = {
+        "document": ["pdf", "docx", "txt", "html", "md"],
+        "image": ["jpg", "jpeg", "png", "webp", "bmp", "tiff"],
+        "video": ["mp4", "avi", "mkv", "mov", "webm", "gif"],
+        "audio": ["mp3", "wav", "ogg", "m4a", "flac", "aac"]
+    }
+
     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"
-                    }
+                    "best_for": "Sharing and printing documents"
                 },
-                "word": {
-                    "best_for": "Editable documents, reports, letters",
-                    "suggested_formats": {
-                        "pdf": "For sharing without edits",
-                        "txt": "For plain text",
-                        "html": "For web publishing"
-                    }
+                "docx": {
+                    "best_for": "Editing documents"
                 },
                 "txt": {
-                    "best_for": "Simple text, code, notes",
-                    "suggested_formats": {
-                        "pdf": "For professional sharing",
-                        "docx": "For formatted documents",
-                        "md": "For documentation"
-                    }
+                    "best_for": "Plain text and notes"
                 }
             },
+
             "image": {
                 "jpg": {
-                    "best_for": "Photographs, web images",
-                    "suggested_formats": {
-                        "png": "For images with transparency",
-                        "webp": "For better web compression",
-                        "bmp": "For uncompressed quality"
-                    }
+                    "best_for": "Photos and web images"
                 },
                 "png": {
-                    "best_for": "Graphics, logos, screenshots with transparency",
-                    "suggested_formats": {
-                        "jpg": "For smaller file size (photos)",
-                        "webp": "For web optimization",
-                        "ico": "For icons"
-                    }
+                    "best_for": "Transparency and graphics"
                 },
                 "webp": {
-                    "best_for": "Web images, modern browsers",
-                    "suggested_formats": {
-                        "png": "For editing",
-                        "jpg": "For compatibility"
-                    }
+                    "best_for": "Modern web compression"
                 }
             },
+
             "video": {
                 "mp4": {
-                    "best_for": "Universal compatibility, web, social media",
-                    "suggested_formats": {
-                        "gif": "For short animations",
-                        "avi": "For editing",
-                        "mkv": "For high quality storage"
-                    }
+                    "best_for": "Universal compatibility"
                 },
-                "avi": {
-                    "best_for": "Editing, Windows compatibility",
-                    "suggested_formats": {
-                        "mp4": "For web sharing",
-                        "mkv": "For compression"
-                    }
+                "mkv": {
+                    "best_for": "High quality storage"
                 }
             },
+
             "audio": {
                 "mp3": {
-                    "best_for": "Music, podcasts, universal playback",
-                    "suggested_formats": {
-                        "wav": "For editing",
-                        "flac": "For lossless quality",
-                        "ogg": "For open source projects"
-                    }
+                    "best_for": "Universal playback"
                 },
-                "wav": {
-                    "best_for": "Professional audio, editing",
-                    "suggested_formats": {
-                        "mp3": "For smaller size",
-                        "flac": "For lossless compression"
-                    }
+                "flac": {
+                    "best_for": "Lossless audio"
                 }
             }
         }
 
-    def ask(self, question: str, context: Dict[str, Any]) -> str:
-        """Process AI queries and provide intelligent responses"""
-        question_lower = question.lower()
+    def ask(
+        self,
+        question: str,
+        context: Dict[str, Any]
+    ) -> str:
+
+        if not question.strip():
+
+            return (
+                "💬 Ask me something like:\n"
+                "• Convert this to PDF\n"
+                "• Best format for web\n"
+                "• Analyze this file"
+            )
+
+        question_lower = question.lower().strip()
+
+        # Greetings
+        if any(
+            x in question_lower
+            for x in ["hi", "hello", "hey"]
+        ):
+
+            return (
+                "👋 Hello! I'm your AI File Assistant.\n\n"
+                "Try:\n"
+                "• Convert this to MP4\n"
+                "• Best format for web\n"
+                "• Analyze this file"
+            )
+
+        # Thanks
+        if "thank" in question_lower:
+
+            return (
+                "😊 You're welcome!"
+            )
+
+        # Conversion request
+        if self.is_conversion_command(
+            question_lower
+        ):
+
+            return self.execute_conversion_command(
+                question_lower,
+                context
+            )
+
+        # Recommendations
+        if any(
+            x in question_lower
+            for x in [
+                "best format",
+                "recommend",
+                "suggest"
+            ]
+        ):
+
+            return self.suggest_format(
+                question_lower,
+                context
+            )
+
+        # Analyze
+        if any(
+            x in question_lower
+            for x in [
+                "analyze",
+                "what is this",
+                "what format"
+            ]
+        ):
+
+            return self.analyze_file(
+                context
+            )
+
+        # Help
+        if any(
+            x in question_lower
+            for x in [
+                "help",
+                "how to"
+            ]
+        ):
+
+            return self.get_help()
+
+        return self.get_general_response()
+
+    def is_conversion_command(
+        self,
+        text: str
+    ) -> bool:
+
+        keywords = [
+            "convert",
+            "change",
+            "transform",
+            "make",
+            "turn into"
+        ]
 
-        # Check for conversion commands
-        if self.is_conversion_command(question_lower):
-            return self.execute_conversion_command(question, context)
+        return any(
+            k in text
+            for k in keywords
+        )
 
-        # 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)
+    def parse_conversion_request(
+        self,
+        text: str
+    ) -> Optional[str]:
 
-        # Check for file analysis
-        elif "what is this" in question_lower or "analyze" in question_lower:
-            return self.analyze_file(context)
+        patterns = [
 
-        # Check for general help
-        elif "help" in question_lower or "how to" in question_lower:
-            return self.get_help(question_lower, context)
+            r"to\s+(\w+)",
 
-        # Default response
-        else:
-            return self.get_general_response(question_lower, context)
+            r"into\s+(\w+)",
 
-    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)
+            r"make\s+(?:it\s+)?(\w+)",
 
-    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+)',
+            r"convert\s+(?:this\s+)?(?:file\s+)?to\s+(\w+)"
         ]
 
         for pattern in patterns:
-            match = re.search(pattern, text.lower())
+
+            match = re.search(
+                pattern,
+                text
+            )
+
             if match:
-                target_format = match.group(1)
-                return target_format, None
 
-        return None, None
+                fmt = match.group(1).lower()
+
+                # normalize jpeg
+                if fmt == "jpeg":
+                    fmt = "jpg"
 
-    def execute_conversion_command(self, question: str, context: Dict[str, Any]) -> str:
-        """Execute a conversion command"""
-        target_format, _ = self.parse_conversion_request(question, context)
+                return fmt
+
+        return None
+
+    def execute_conversion_command(
+        self,
+        question: str,
+        context: Dict[str, Any]
+    ) -> str:
+
+        target_format = self.parse_conversion_request(
+            question
+        )
 
         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()
+            return self.get_conversion_help()
 
-        if not current_type or not current_format:
-            return "⚠️ Please select a file type and output format first in the settings panel."
+        file_type = context.get(
+            "file_type",
+            ""
+        ).lower()
+
+        current_format = context.get(
+            "output_format",
+            ""
+        ).lower()
+
+        if not file_type:
+
+            return (
+                "⚠ Please select a file type first."
+            )
+
+        supported = self.SUPPORTED_FORMATS.get(
+            file_type,
+            []
+        )
+
+        if target_format not in supported:
+
+            return (
+                f"❌ {target_format.upper()} "
+                f"is not supported for "
+                f"{file_type} files.\n\n"
+                f"Supported:\n"
+                f"{', '.join(supported).upper()}"
+            )
+
+        response = (
+            "🎯 Conversion Ready\n\n"
+            f"Current Type: {file_type.title()}\n"
+            f"Target Format: {target_format.upper()}\n\n"
+        )
+
+        advice = self.get_format_advice(
+            file_type,
+            target_format
+        )
+
+        if advice:
+
+            response += (
+                f"💡 Tip: {advice}\n\n"
+            )
+
+        response += (
+            "✅ Now:\n"
+            "1. Select the format\n"
+            "2. Add files\n"
+            "3. Click Start Conversion"
+        )
 
-        response = f"🎯 **Conversion Command Received**\n\n"
-        response += f"Converting from **{current_format.upper()}** to **{target_format.upper()}**...\n\n"
+        return response
 
-        # 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"]
-        }
+    def suggest_format(
+        self,
+        question: str,
+        context: Dict[str, Any]
+    ) -> str:
 
-        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"
+        file_type = context.get(
+            "file_type",
+            ""
+        ).lower()
 
-            # 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"
+        if not file_type:
 
-        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 (
+                "⚠ Please select a file type first."
+            )
 
-        return response
+        recommendations = {
 
-    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)"
+                "web": "HTML",
+                "print": "PDF",
+                "edit": "DOCX",
+                "small": "TXT"
             },
+
             "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)"
+                "web": "WEBP",
+                "quality": "PNG",
+                "photo": "JPG",
+                "transparent": "PNG"
             },
+
             "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)"
+                "web": "MP4",
+                "quality": "MKV",
+                "small": "WEBM"
             },
+
             "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)"
+                "quality": "FLAC",
+                "small": "MP3",
+                "edit": "WAV"
             }
         }
 
-        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"
+        use_case = "web"
+
+        keywords = {
+            "print": ["print"],
+            "edit": ["edit"],
+            "small": ["small", "compress"],
+            "quality": ["quality", "lossless"],
+            "photo": ["photo"],
+            "transparent": ["transparent"]
         }
 
-        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!"
+        for case, words in keywords.items():
+
+            if any(w in question for w in words):
+
+                use_case = case
+                break
+
+        fmt = recommendations.get(
+            file_type,
+            {}
+        ).get(
+            use_case,
+            "PDF"
+        )
+
+        return (
+            f"📋 Recommended Format\n\n"
+            f"For {use_case} use:\n"
+            f"✅ {fmt}\n\n"
+            f"Type:\n"
+            f"Convert this to {fmt}"
+        )
+
+    def analyze_file(
+        self,
+        context: Dict[str, Any]
+    ) -> str:
+
+        file_type = context.get(
+            "file_type",
+            "Unknown"
+        )
+
+        fmt = context.get(
+            "output_format",
+            "Unknown"
+        ).lower()
+
+        response = (
+            "🔍 File Analysis\n\n"
+            f"Type: {file_type.title()}\n"
+            f"Format: {fmt.upper()}\n\n"
+        )
+
+        kb = self.knowledge_base.get(
+            file_type,
+            {}
+        )
+
+        if fmt in kb:
+
+            response += (
+                f"📌 Best For:\n"
+                f"{kb[fmt]['best_for']}"
+            )
+
+        else:
+
+            response += (
+                "No detailed analysis available."
+            )
 
         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()
+    def get_help(self) -> str:
 
-        response = f"🔍 **File Analysis**\n\n"
-        response += f"📄 Type: {current_type.title()}\n"
-        response += f"🎯 Current format: {current_format}\n"
+        return (
+            "🤖 AI Assistant Help\n\n"
+            "Commands:\n"
+            "• Convert this to PDF\n"
+            "• Best format for web\n"
+            "• Analyze this file\n"
+            "• Compress this video\n\n"
+            "Supported:\n"
+            "Documents, Images, Videos, Audio"
+        )
 
-        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"
+    def get_general_response(self) -> str:
 
-            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 (
+            "🤖 AI Assistant Ready\n\n"
+            "Try:\n"
+            "• Convert this to PNG\n"
+            "• Best format for web\n"
+            "• Analyze this file"
+        )
 
-        return response
+    def get_format_advice(
+        self,
+        file_type: str,
+        target_format: str
+    ) -> str:
 
-    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?'"
+        tips = {
 
-        return response
+            ("image", "jpg"):
+                "Best for photos and smaller size.",
 
-    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"
+            ("image", "png"):
+                "Supports transparency.",
 
-        # Try to understand intent
-        if "thank" in question:
-            return "You're welcome! 😊 Let me know if you need help with any conversions!"
+            ("image", "webp"):
+                "Excellent modern compression.",
 
-        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'!"
+            ("video", "mp4"):
+                "Most compatible format.",
 
-        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'"
+            ("video", "gif"):
+                "Keep clips short for smaller size.",
 
-        return response
+            ("audio", "mp3"):
+                "Universal audio playback.",
+
+            ("audio", "flac"):
+                "Lossless quality.",
 
-    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."
+            ("document", "pdf"):
+                "Preserves formatting.",
+
+            ("document", "txt"):
+                "Very small file size."
         }
 
-        return advice.get((file_type, target_format), "")
+        return tips.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!
-"""
+
+        return (
+            "🎯 Conversion Help\n\n"
+            "Examples:\n"
+            "• Convert this to PDF\n"
+            "• Make it MP3\n"
+            "• Change this to PNG\n"
+            "• Transform to MP4"
+        )