Add AI-powered project requirements generation feature

app.py

@@ -435,6 +435,258 @@ class CatalogValidator:
         return warnings
 
 
+class ProjectRequirementsGenerator:
+    """Generate requirements.txt from project description using LLM."""
+    
+    def __init__(self, use_llm: bool = True):
+        """
+        Initialize project requirements generator.
+        
+        Args:
+            use_llm: If True, uses Hugging Face Inference API
+                    If False, uses rule-based suggestions
+        """
+        self.use_llm = use_llm
+        # Using a better model for code generation
+        # Try to use a code generation model, fallback to GPT-2
+        self.api_url = "https://api-inference.huggingface.co/models/bigcode/starcoder"
+        self.fallback_url = "https://api-inference.huggingface.co/models/gpt2"
+        self.headers = {"Content-Type": "application/json"}
+    
+    def generate_requirements(self, project_description: str) -> Tuple[str, str]:
+        """
+        Generate requirements.txt from project description.
+        
+        Args:
+            project_description: User's description of their project
+            
+        Returns:
+            Tuple of (requirements_text, explanations_text)
+        """
+        if not project_description or not project_description.strip():
+            return "", ""
+        
+        # Always try rule-based first as it's more reliable
+        requirements, explanations = self._rule_based_suggestions(project_description)
+        
+        # Try LLM to enhance the suggestions if enabled
+        if self.use_llm:
+            prompt = self._create_requirements_prompt(project_description)
+            llm_response = self._call_llm_for_requirements(prompt)
+            llm_requirements, llm_explanations = self._parse_llm_response(llm_response)
+            
+            # If LLM generated valid requirements, use them (or merge with rule-based)
+            if llm_requirements and len(llm_requirements.strip()) > 10:
+                # Merge: prefer LLM but keep rule-based if LLM is incomplete
+                if len(llm_requirements) > len(requirements):
+                    requirements = llm_requirements
+                    explanations = llm_explanations if llm_explanations else explanations
+                else:
+                    # Combine both
+                    combined = set(requirements.split('\n'))
+                    combined.update(llm_requirements.split('\n'))
+                    requirements = '\n'.join([r for r in combined if r.strip()])
+        
+        return requirements, explanations
+    
+    def _create_requirements_prompt(self, description: str) -> str:
+        """Create a prompt for generating requirements.txt."""
+        prompt = f"""You are a Python expert. Based on this project description, generate a requirements.txt file with appropriate Python packages.
+
+Project Description:
+{description}
+
+Generate a requirements.txt file with:
+1. Essential packages needed for this project
+2. Appropriate version pins where necessary
+3. Format: one package per line with version (e.g., "pandas==2.0.3" or "fastapi>=0.100.0")
+
+For each package, provide a brief explanation of why it's needed.
+
+Format your response as:
+REQUIREMENTS:
+package1==version1
+package2>=version2
+...
+
+EXPLANATIONS:
+- package1: Brief explanation of why it's needed
+- package2: Brief explanation of why it's needed
+...
+
+Keep it practical and focused on the most important dependencies (5-15 packages typically).
+"""
+        return prompt
+    
+    def _call_llm_for_requirements(self, prompt: str) -> str:
+        """Call LLM API to generate requirements."""
+        try:
+            # Try the code generation model first
+            payload = {
+                "inputs": prompt,
+                "parameters": {
+                    "max_new_tokens": 500,
+                    "temperature": 0.3,
+                    "return_full_text": False
+                }
+            }
+            
+            response = requests.post(
+                self.api_url,
+                headers=self.headers,
+                json=payload,
+                timeout=15
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                if isinstance(result, list) and len(result) > 0:
+                    generated_text = result[0].get('generated_text', '')
+                    if generated_text:
+                        return generated_text.strip()
+            
+            # Fallback to GPT-2
+            response = requests.post(
+                self.fallback_url,
+                headers=self.headers,
+                json=payload,
+                timeout=15
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                if isinstance(result, list) and len(result) > 0:
+                    generated_text = result[0].get('generated_text', '')
+                    if generated_text:
+                        return generated_text.strip()
+            
+            return ""
+        
+        except Exception as e:
+            print(f"LLM API error: {e}")
+            return ""
+    
+    def _parse_llm_response(self, response: str) -> Tuple[str, str]:
+        """Parse LLM response to extract requirements and explanations."""
+        if not response:
+            return "", ""
+        
+        requirements = []
+        explanations = []
+        
+        # Try to extract REQUIREMENTS section
+        if "REQUIREMENTS:" in response:
+            req_section = response.split("REQUIREMENTS:")[1]
+            if "EXPLANATIONS:" in req_section:
+                req_section = req_section.split("EXPLANATIONS:")[0]
+            
+            for line in req_section.strip().split('\n'):
+                line = line.strip()
+                if line and not line.startswith('#') and not line.startswith('-'):
+                    # Clean up the line
+                    line = line.split('#')[0].strip()  # Remove comments
+                    if line and ('==' in line or '>=' in line or '<=' in line or '>' in line or '<' in line or not any(c in line for c in '=<>')):
+                        requirements.append(line)
+        
+        # Try to extract EXPLANATIONS section
+        if "EXPLANATIONS:" in response:
+            exp_section = response.split("EXPLANATIONS:")[1]
+            for line in exp_section.strip().split('\n'):
+                line = line.strip()
+                if line and line.startswith('-'):
+                    explanations.append(line[1:].strip())
+        
+        # If parsing failed, try to extract package names from the response
+        if not requirements:
+            # Look for lines that look like package specifications
+            for line in response.split('\n'):
+                line = line.strip()
+                # Check if it looks like a package (has letters, maybe numbers, maybe version)
+                if line and ('==' in line or '>=' in line or '<=' in line):
+                    parts = line.split()
+                    if parts:
+                        requirements.append(parts[0])
+        
+        requirements_text = '\n'.join(requirements[:20])  # Limit to 20 packages
+        explanations_text = '\n'.join(explanations[:20]) if explanations else ""
+        
+        return requirements_text, explanations_text
+    
+    def _rule_based_suggestions(self, description: str) -> Tuple[str, str]:
+        """Generate rule-based suggestions when LLM is unavailable."""
+        desc_lower = description.lower()
+        suggestions = []
+        explanations = []
+        
+        # RAG / Chatbot / PDF processing
+        if any(word in desc_lower for word in ['rag', 'chatbot', 'pdf', 'document', 'query', 'retrieval']):
+            suggestions.append("streamlit>=1.28.0")
+            suggestions.append("langchain>=0.1.0")
+            suggestions.append("pypdf>=3.17.0")
+            if 'openai' in desc_lower or 'gpt' in desc_lower:
+                suggestions.append("openai>=1.0.0")
+            else:
+                suggestions.append("openai>=1.0.0")
+            suggestions.append("chromadb>=0.4.0")
+            explanations.append("- streamlit: Build interactive web apps for your chatbot interface")
+            explanations.append("- langchain: Framework for building RAG applications")
+            explanations.append("- pypdf: PDF parsing and text extraction")
+            explanations.append("- openai: OpenAI API for LLM integration")
+            explanations.append("- chromadb: Vector database for document embeddings")
+        
+        # Web frameworks
+        if any(word in desc_lower for word in ['web', 'api', 'server', 'backend', 'rest']):
+            suggestions.append("fastapi>=0.100.0")
+            suggestions.append("uvicorn[standard]>=0.23.0")
+            explanations.append("- fastapi: Modern web framework for building APIs")
+            explanations.append("- uvicorn: ASGI server to run FastAPI applications")
+        
+        # Data science
+        if any(word in desc_lower for word in ['data', 'analysis', 'csv', 'excel', 'dataframe', 'pandas']):
+            suggestions.append("pandas>=2.0.0")
+            suggestions.append("numpy>=1.24.0")
+            explanations.append("- pandas: Data manipulation and analysis")
+            explanations.append("- numpy: Numerical computing library")
+        
+        # Machine learning
+        if any(word in desc_lower for word in ['ml', 'machine learning', 'model', 'train', 'neural', 'deep learning', 'ai']):
+            suggestions.append("scikit-learn>=1.3.0")
+            if 'pytorch' in desc_lower or 'torch' in desc_lower:
+                suggestions.append("torch>=2.0.0")
+                explanations.append("- torch: PyTorch deep learning framework")
+            elif 'tensorflow' in desc_lower or 'tf' in desc_lower:
+                suggestions.append("tensorflow>=2.13.0")
+                explanations.append("- tensorflow: TensorFlow deep learning framework")
+            explanations.append("- scikit-learn: Machine learning algorithms and utilities")
+        
+        # Database
+        if any(word in desc_lower for word in ['database', 'sql', 'db', 'postgres', 'mysql']):
+            suggestions.append("sqlalchemy>=2.0.0")
+            explanations.append("- sqlalchemy: SQL toolkit and ORM")
+        
+        # HTTP requests
+        if any(word in desc_lower for word in ['http', 'request', 'fetch', 'download']):
+            suggestions.append("requests>=2.31.0")
+            explanations.append("- requests: HTTP library for making API calls")
+        
+        # Environment variables
+        if any(word in desc_lower for word in ['config', 'env', 'environment', 'settings']):
+            suggestions.append("python-dotenv>=1.0.0")
+            explanations.append("- python-dotenv: Load environment variables from .env file")
+        
+        # If no specific matches, provide common packages
+        if not suggestions:
+            suggestions.append("requests>=2.31.0")
+            suggestions.append("python-dotenv>=1.0.0")
+            explanations.append("- requests: HTTP library for API calls and web requests")
+            explanations.append("- python-dotenv: Manage environment variables and configuration")
+        
+        requirements_text = '\n'.join(suggestions) if suggestions else ""
+        explanations_text = '\n'.join(explanations) if explanations else ""
+        
+        return requirements_text, explanations_text
+
+
 class ExplanationEngine:
     """Generate intelligent explanations for dependency conflicts using LLM."""
     
@@ -589,6 +841,7 @@ Keep it under 150 words and use plain language.
 
 
 def process_dependencies(
+    project_description: str,
     library_list: str,
     requirements_text: str,
     uploaded_file,
@@ -604,6 +857,20 @@ def process_dependencies(
 ) -> Tuple[str, str, str]:
     """Main processing function for Gradio interface."""
     
+    # Generate requirements from project description if provided
+    generated_requirements = ""
+    generation_explanations = ""
+    if project_description and project_description.strip():
+        generator = ProjectRequirementsGenerator(use_llm=True)
+        generated_requirements, generation_explanations = generator.generate_requirements(project_description)
+        
+        # If we generated requirements, add them to the requirements_text
+        if generated_requirements:
+            if requirements_text:
+                requirements_text = generated_requirements + "\n" + requirements_text
+            else:
+                requirements_text = generated_requirements
+    
     # Collect dependencies from all sources
     all_dependencies = []
     
@@ -780,6 +1047,22 @@ def process_dependencies(
     output_parts = []
     output_parts.append("## Dependency Analysis Results\n\n")
     
+    # Show generated requirements if project description was provided
+    if project_description and project_description.strip() and generated_requirements:
+        output_parts.append("### Generated Requirements from Project Description\n\n")
+        output_parts.append(f"**Project:** {project_description[:100]}{'...' if len(project_description) > 100 else ''}\n\n")
+        output_parts.append("**Suggested Packages:**\n")
+        output_parts.append("```\n")
+        output_parts.append(generated_requirements)
+        output_parts.append("\n```\n\n")
+        
+        if generation_explanations:
+            output_parts.append("**Why these packages?**\n")
+            output_parts.append(generation_explanations)
+            output_parts.append("\n\n")
+        
+        output_parts.append("---\n\n")
+    
     # Show ML prediction if available
     if ML_AVAILABLE and ml_conflict_prediction is not None:
         if ml_conflict_prediction:
@@ -849,6 +1132,7 @@ def create_interface():
         
         | Feature | Status | Description |
         |---------|--------|-------------|
+        | **LLM Requirements Generation** | Active | Generate requirements.txt from project description using AI |
         | **LLM Reasoning** | Active | AI-powered natural language explanations for conflicts |
         | **ML Conflict Prediction** | {"Available" if ML_AVAILABLE else "Not Loaded"} | Machine learning model predicts conflicts before analysis |
         | **Embedding-Based Spell Check** | {"Available" if ML_AVAILABLE else "Not Loaded"} | Semantic similarity matching for package names |
@@ -857,6 +1141,29 @@ def create_interface():
         
         """)
         
+        # Project Description Input (Optional)
+        with gr.Row():
+            with gr.Column(scale=3):
+                project_description_input = gr.Textbox(
+                    label="Project Description (Optional) - AI-Powered Requirements Generation",
+                    placeholder="Describe your project idea here...\nExample: 'I want to build a web API for data analysis with machine learning capabilities'",
+                    lines=4,
+                    info="Describe your project and AI will suggest required libraries with explanations.",
+                    value=""
+                )
+            with gr.Column(scale=1):
+                generate_requirements_btn = gr.Button(
+                    "Generate Requirements from Description",
+                    variant="secondary",
+                    size="lg"
+                )
+                generated_requirements_display = gr.Markdown(
+                    label="Generated Requirements Preview",
+                    value="AI-generated requirements preview will appear here after clicking the button above."
+                )
+        
+        gr.Markdown("---")
+        
         with gr.Row():
             with gr.Column(scale=1):
                 gr.Markdown("### Input Methods")
@@ -974,6 +1281,29 @@ def create_interface():
                     visible=True
                 )
         
+        def generate_requirements_only(project_desc):
+            """Generate requirements from project description only."""
+            if not project_desc or not project_desc.strip():
+                return "", ""
+            
+            generator = ProjectRequirementsGenerator(use_llm=True)
+            requirements, explanations = generator.generate_requirements(project_desc)
+            
+            if requirements:
+                output = f"## Generated Requirements\n\n"
+                output += f"**Project:** {project_desc[:100]}{'...' if len(project_desc) > 100 else ''}\n\n"
+                output += "**Suggested Packages:**\n```\n"
+                output += requirements
+                output += "\n```\n\n"
+                if explanations:
+                    output += "**Why these packages?**\n"
+                    output += explanations
+                # Also return the requirements text for the textbox
+                return output, requirements
+            else:
+                error_msg = "Could not generate requirements. Please try a more detailed description or check your connection."
+                return error_msg, ""
+        
         def process_and_download(*args):
             # Extract all arguments
             result_text, resolved_text, ml_details = process_dependencies(*args)
@@ -993,9 +1323,77 @@ def create_interface():
             
             return result_text, resolved_text, temp_file if temp_file else None, ml_output_text
         
+        # Button to generate requirements from description
+        def generate_and_update(project_desc, existing_reqs):
+            """Generate requirements and update the requirements input."""
+            if not project_desc or not project_desc.strip():
+                return "Please enter a project description first.", existing_reqs
+            
+            generator = ProjectRequirementsGenerator(use_llm=True)
+            requirements, explanations = generator.generate_requirements(project_desc)
+            
+            # Check if we got valid requirements (rule-based should always return something)
+            if requirements and requirements.strip() and len(requirements.strip()) > 5:
+                # Create preview output
+                preview = f"## Generated Requirements\n\n"
+                preview += f"**Project:** {project_desc[:100]}{'...' if len(project_desc) > 100 else ''}\n\n"
+                preview += "**Suggested Packages:**\n```\n"
+                preview += requirements
+                preview += "\n```\n\n"
+                if explanations and explanations.strip():
+                    preview += "**Why these packages?**\n"
+                    preview += explanations
+                preview += "\n\n*Requirements have been added to the 'Requirements.txt Content' box below. You can edit them before analysis.*"
+                
+                # Update requirements input (append or replace)
+                if existing_reqs and existing_reqs.strip():
+                    updated_reqs = requirements + "\n" + existing_reqs
+                else:
+                    updated_reqs = requirements
+                
+                return preview, updated_reqs
+            else:
+                # Fallback - generate basic requirements
+                desc_lower = project_desc.lower()
+                basic_reqs = []
+                basic_explanations = []
+                
+                if 'streamlit' in desc_lower or 'web' in desc_lower or 'app' in desc_lower:
+                    basic_reqs.append("streamlit>=1.28.0")
+                    basic_explanations.append("- streamlit: Build interactive web applications")
+                
+                if 'pdf' in desc_lower or 'document' in desc_lower:
+                    basic_reqs.append("pypdf>=3.17.0")
+                    basic_explanations.append("- pypdf: PDF parsing and text extraction")
+                
+                if 'rag' in desc_lower or 'chatbot' in desc_lower or 'llm' in desc_lower:
+                    basic_reqs.append("langchain>=0.1.0")
+                    basic_reqs.append("openai>=1.0.0")
+                    basic_explanations.append("- langchain: Framework for building LLM applications")
+                    basic_explanations.append("- openai: OpenAI API integration")
+                
+                if basic_reqs:
+                    reqs_text = '\n'.join(basic_reqs)
+                    exp_text = '\n'.join(basic_explanations)
+                    preview = f"## Generated Requirements\n\n**Project:** {project_desc[:100]}\n\n**Suggested Packages:**\n```\n{reqs_text}\n```\n\n**Why these packages?**\n{exp_text}"
+                    if existing_reqs and existing_reqs.strip():
+                        updated_reqs = reqs_text + "\n" + existing_reqs
+                    else:
+                        updated_reqs = reqs_text
+                    return preview, updated_reqs
+                
+                error_msg = "## Could not generate requirements\n\nPlease try a more detailed description with keywords like: web, API, data analysis, machine learning, PDF, chatbot, etc."
+                return error_msg, existing_reqs
+        
+        generate_requirements_btn.click(
+            fn=generate_and_update,
+            inputs=[project_description_input, requirements_input],
+            outputs=[generated_requirements_display, requirements_input]
+        )
+        
         process_btn.click(
             fn=process_and_download,
-            inputs=[library_input, requirements_input, file_upload, python_version, device, os_type, mode, resolution_strategy, use_llm, use_ml_prediction, use_ml_spellcheck, show_ml_details],
+            inputs=[project_description_input, library_input, requirements_input, file_upload, python_version, device, os_type, mode, resolution_strategy, use_llm, use_ml_prediction, use_ml_spellcheck, show_ml_details],
             outputs=[output_display, resolved_output, download_btn, ml_output]
         )
         
@@ -1003,15 +1401,19 @@ def create_interface():
         ---
         ### How to Use
         
-        1. **Input your dependencies** using any of the three methods (or combine them)
-        2. **Configure your environment** (Python version, device, OS)
-        3. **Choose analysis mode**: Quick for fast results, Deep for complete dependency tree
-        4. **Select resolution strategy**: How to handle version conflicts
-        5. **Click "Analyze & Resolve Dependencies"**
-        6. **Review the results** and download the resolved requirements.txt
+        1. **(Optional) Describe your project** in the "Project Description" box - AI will suggest required libraries
+        2. **Input your dependencies** using any of the three methods (or combine them)
+        3. **Configure your environment** (Python version, device, OS)
+        4. **Enable AI/ML features** (LLM explanations, ML predictions, ML spell-check)
+        5. **Choose analysis mode**: Quick for fast results, Deep for complete dependency tree
+        6. **Select resolution strategy**: How to handle version conflicts
+        7. **Click "Analyze & Resolve Dependencies"**
+        8. **Review the results** including AI-generated requirements and explanations
+        9. **Download the resolved requirements.txt**
         
         ### Features
         
+        - **AI Requirements Generation**: Describe your project and get suggested libraries with explanations
         - Parse multiple input formats
         - Detect version conflicts
         - Check compatibility across dependency graph