added Readme geneartor code

app.py

@@ -0,0 +1,13 @@
+import gradio as gr
+from src.ui import create_ui
+
+def main():
+    # Launch the UI
+    try:
+        demo = create_ui()
+        demo.launch(show_error=True)
+    except Exception as e:
+        print(f"Error launching Gradio app: {e}")
+
+if __name__ == "__main__":
+    main()

src/file_scanner.py

@@ -0,0 +1,84 @@
+import os
+import json
+import re
+from typing import Dict, Any
+
+def analyze_code_for_purpose(file_path: str) -> str:
+    """
+    Analyze a Python file to extract purpose from docstrings or comments.
+    """
+    purpose = []
+    try:
+        with open(file_path, 'r', encoding='utf-8') as file:
+            lines = file.readlines()
+            # Extract comments or docstrings from the first 30 lines
+            for line in lines[:30]:
+                # Match docstrings or comments
+                if re.match(r'^\s*#', line) or re.match(r'^\s*"""', line):
+                    purpose.append(line.strip("# ").strip('"""').strip())
+    except Exception:
+        pass
+    return " ".join(purpose)[:250]  # Limit to 250 characters
+
+def quick_scan_project(project_path: str) -> Dict[str, Any]:
+    """
+    Perform a detailed scan of the project directory, including purpose analysis.
+    """
+    def get_all_files_and_dirs(path):
+        files = []
+        dirs = []
+        for root, directories, filenames in os.walk(path):
+            for file in filenames:
+                files.append(os.path.relpath(os.path.join(root, file), path))
+            for dir in directories:
+                dirs.append(os.path.relpath(os.path.join(root, dir), path))
+        return {
+            'files': files[:10],  # Limit to 10 for concise output
+            'directories': dirs[:10]
+        }
+
+    scan_result = get_all_files_and_dirs(project_path)
+    top_level_files = os.listdir(project_path)
+
+    # Detect language and main file
+    main_files = {
+        'Python': ['main.py', 'app.py', 'index.py'],
+        'JavaScript': ['index.js', 'app.js', 'server.js'],
+        'Java': ['Main.java', 'App.java']
+    }
+
+    language = 'Unknown'
+    main_file = ''
+    project_purpose = ''
+    for lang, possible_mains in main_files.items():
+        for main in possible_mains:
+            if main in top_level_files:
+                language = lang
+                main_file = main
+                project_purpose = analyze_code_for_purpose(os.path.join(project_path, main))
+                break
+        if language != 'Unknown':
+            break
+
+    # Detect dependencies
+    dependencies = []
+    try:
+        if 'requirements.txt' in top_level_files:
+            with open(os.path.join(project_path, 'requirements.txt'), 'r') as f:
+                dependencies = [line.strip().split('==')[0] for line in f 
+                                if line.strip() and not line.startswith('#')][:5]
+        elif 'package.json' in top_level_files:
+            with open(os.path.join(project_path, 'package.json'), 'r') as f:
+                package_data = json.load(f)
+                dependencies = list(package_data.get('dependencies', {}).keys())[:5]
+    except Exception:
+        pass
+
+    return {
+        "files": scan_result['files'],
+        "directories": scan_result['directories'],
+        "main_file": main_file or "Main file not detected",
+        "language": language,
+        "dependencies": dependencies or ["No dependencies detected"],
+        "purpose": project_purpose or "No purpose detected from the code"
+    }

src/generator.py

@@ -0,0 +1,191 @@
+import logging
+import os
+import re
+from typing import Any, Dict, List
+from langchain_groq import ChatGroq
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from .file_scanner import quick_scan_project
+
+class AIReadmeGenerator:
+    def __init__(self, api_key: str):
+        self.llm = ChatGroq(
+            api_key=api_key, 
+            model_name="llama3-70b-8192"
+        )
+
+    def read_file_content(self, file_path: str) -> str:
+        """
+        Read the content of a file, handling different encodings and file sizes.
+        
+        Args:
+            file_path (str): Path to the file to read
+        
+        Returns:
+            str: File content or error message
+        """
+        try:
+            # Limit file reading to prevent memory issues
+            with open(file_path, 'r', encoding='utf-8') as file:
+                # Read first 10000 characters to prevent large files from overwhelming the system
+                return file.read(10000)
+        except Exception as e:
+            return f"Error reading file {file_path}: {str(e)}"
+
+    def analyze_project_structure(self, project_path: str) -> Dict[str, Any]:
+        """
+        Perform a comprehensive analysis of the project.
+        
+        Args:
+            project_path (str): Path to the project directory
+        
+        Returns:
+            Dict: Detailed project analysis
+        """
+        # Use existing quick_scan_project for initial analysis
+        project_info = quick_scan_project(project_path)
+        
+        # Collect file contents
+        file_contents = {}
+        for file in project_info.get('files', []):
+            full_path = os.path.join(project_path, file)
+            if os.path.isfile(full_path):
+                file_contents[file] = self.read_file_content(full_path)
+        
+        # Extract docstrings and comments from main files
+        code_insights = {}
+        main_files = ['app.py', 'main.py', 'src/ui.py', 'src/generator.py']
+        for main_file in main_files:
+            full_path = os.path.join(project_path, main_file)
+            if os.path.exists(full_path):
+                code_insights[main_file] = self.extract_code_insights(full_path)
+        
+        # Combine all information
+        comprehensive_analysis = {
+            "project_structure": project_info,
+            "file_contents": file_contents,
+            "code_insights": code_insights,
+            "requirements": self.read_requirements(project_path)
+        }
+        
+        return comprehensive_analysis
+
+    def extract_code_insights(self, file_path: str) -> Dict[str, str]:
+        """
+        Extract insights from Python files.
+        
+        Args:
+            file_path (str): Path to the Python file
+        
+        Returns:
+            Dict: Extracted insights including docstrings, key functions, etc.
+        """
+        insights = {
+            "module_docstring": "",
+            "key_functions": [],
+            "key_classes": []
+        }
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as file:
+                content = file.read()
+                
+                # Extract module-level docstring
+                module_docstring_match = re.search(r'"""(.*?)"""', content, re.DOTALL)
+                if module_docstring_match:
+                    insights['module_docstring'] = module_docstring_match.group(1).strip()
+                
+                # Find key functions
+                function_matches = re.findall(r'def\s+(\w+)\(.*?\):\s*"""(.*?)"""', content, re.DOTALL)
+                insights['key_functions'] = [
+                    f"{name}: {desc.strip()}" 
+                    for name, desc in function_matches
+                ]
+                
+                # Find key classes
+                class_matches = re.findall(r'class\s+(\w+).*?:\s*"""(.*?)"""', content, re.DOTALL)
+                insights['key_classes'] = [
+                    f"{name}: {desc.strip()}" 
+                    for name, desc in class_matches
+                ]
+        except Exception as e:
+            insights['error'] = str(e)
+        
+        return insights
+
+    def read_requirements(self, project_path: str) -> List[str]:
+        """
+        Read project requirements file.
+        
+        Args:
+            project_path (str): Path to the project directory
+        
+        Returns:
+            List[str]: List of requirements
+        """
+        try:
+            req_path = os.path.join(project_path, 'requirements.txt')
+            if os.path.exists(req_path):
+                with open(req_path, 'r') as f:
+                    return [line.strip() for line in f if line.strip() and not line.startswith('#')]
+            return []
+        except Exception:
+            return []
+
+    def generate_concise_readme(self, project_path: str) -> str:
+        """
+        Generate a README based on comprehensive project analysis.
+        
+        Args:
+            project_path (str): Path to the project directory
+        
+        Returns:
+            str: Generated README content
+        """
+        # Analyze the project comprehensively
+        project_analysis = self.analyze_project_structure(project_path)
+        
+        # Prepare a detailed prompt for the LLM
+        template = """
+        Generate a comprehensive README.md based on the following project analysis:
+
+        PROJECT STRUCTURE:
+        {project_structure}
+
+        FILE CONTENTS:
+        {file_contents}
+
+        CODE INSIGHTS:
+        {code_insights}
+
+        REQUIREMENTS:
+        {requirements}
+
+        Based on this information, create a professional, detailed README.md that:
+        - Explains the project's purpose and functionality
+        - Describes key features and components
+        - Provides clear setup and usage instructions
+        - Highlights technical details
+        - Includes any relevant dependencies or prerequisites
+
+        Ensure the README is informative, well-structured, and tailored to the specific project.
+        """
+
+        # Prepare context for the LLM
+        context = {
+            "project_structure": str(project_analysis.get('project_structure', 'No structure information')),
+            "file_contents": '\n'.join([f"{k}:\n{v}" for k, v in project_analysis.get('file_contents', {}).items()]),
+            "code_insights": '\n'.join([f"{k}:\n{str(v)}" for k, v in project_analysis.get('code_insights', {}).items()]),
+            "requirements": '\n'.join(project_analysis.get('requirements', []))
+        }
+
+        try:
+            # Generate README using LLM
+            prompt = ChatPromptTemplate.from_template(template)
+            chain = prompt | self.llm | StrOutputParser()
+            
+            readme_content = chain.invoke(context)
+            return readme_content.strip()
+        except Exception as e:
+            logging.error(f"README generation error: {str(e)}")
+            return f"# Project README\n\nUnable to generate README automatically.\n\nError: {str(e)}"

src/ui.py

@@ -0,0 +1,108 @@
+import os
+import gradio as gr
+import tempfile
+import zipfile
+from groq import Groq
+from dotenv import load_dotenv
+from .generator import AIReadmeGenerator
+
+# Validate the API key using the provided format
+def validate_api_key(api_key):
+    """
+    Validate the API key using a test completion request.
+    """
+    try:
+        client = Groq(api_key=api_key)
+        response = client.chat.completions.create(
+            model="llama-3.1-8b-instant",
+            messages=[
+                {"role": "system", "content": "Validation test for API key."},
+                {"role": "user", "content": "Hello, world!"}
+            ],
+            temperature=0.1,
+            max_tokens=5,
+        )
+        if response and response.choices:
+            return True, "API key is valid!"
+        else:
+            return False, "API key validation failed: Empty response."
+    except Exception as e:
+        return False, f"Invalid API key. Error: {str(e)}"
+
+# Generate README
+def generate_readme_with_key(project_folder, api_key):
+    """
+    Generate the README for a given project folder using the provided API key.
+    """
+    try:
+        # Use the API key dynamically
+        generator = AIReadmeGenerator(api_key)
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Extract uploaded ZIP file
+            with zipfile.ZipFile(project_folder, 'r') as zip_ref:
+                zip_ref.extractall(temp_dir)
+            
+            # Generate the README
+            readme_content = generator.generate_concise_readme(temp_dir)
+            
+            return readme_content, readme_content
+    except zipfile.BadZipFile:
+        return "Error: Uploaded file is not a valid ZIP archive.", "Error: Invalid ZIP archive."
+    except Exception as e:
+        return f"Error generating README: {str(e)}", f"Error generating README: {str(e)}"
+
+# Handle user login
+def on_login(api_key):
+    is_valid, message = validate_api_key(api_key)
+    if is_valid:
+        return gr.update(visible=False), gr.update(visible=True), gr.Markdown(f"**Success!** {message}", visible=True)
+    else:
+        return gr.update(visible=True), gr.update(visible=False), gr.Markdown(f"**Error!** {message}", visible=True)
+
+# Create Gradio UI
+def create_ui():
+    with gr.Blocks(title="AI README Generator") as demo:
+        # Login Section
+        with gr.Column(visible=True) as login_section:
+            gr.Markdown("## Login to Access the AI README Generator")
+            api_key_input = gr.Textbox(label="Enter your API Key:", type="password")
+            login_button = gr.Button("Login")
+            login_feedback = gr.Markdown(visible=False)
+
+            gr.Markdown("""
+            ### Login Instructions
+            1. **Sign Up / Log In** at [Groq API Portal](https://console.groq.com/keys).
+            2. **Generate an API Key** in the API Keys section.
+            3. **Copy and Paste the API Key** into the box above.
+            4. **Click Login** to proceed.
+            """)
+
+        # README Generator Section
+        with gr.Column(visible=False) as readme_section:
+            gr.Markdown("# AI README Craft")
+            gr.Markdown("""
+            ## Instructions
+            - **Step 1:** Convert your project folder into a ZIP file.
+            - **Step 2:** Upload the ZIP file using the form below.
+            - **Step 3:** Click the **Generate README** button.
+            - **Note:** Larger files may take more time to process. Please be patient!
+            """)
+            folder_input = gr.File(file_count="single", type="filepath", label="📂 Upload Your Project (ZIP)")
+            generate_btn = gr.Button("✨ Generate README")
+            with gr.Row():
+                readme_output = gr.Textbox(lines=20, interactive=False, label="Generated README")
+                readme_markdown = gr.Markdown(label="README Preview")
+        
+        # Button Click Events
+        login_button.click(
+            on_login,
+            inputs=[api_key_input],
+            outputs=[login_section, readme_section, login_feedback]
+        )
+        generate_btn.click(
+            generate_readme_with_key,
+            inputs=[folder_input, api_key_input],
+            outputs=[readme_output, readme_markdown]
+        )
+
+    return demo