Upload folder using huggingface_hub

LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Eslam Tarek
+
+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.

agents/code_overview_agents.py

@@ -0,0 +1,108 @@
+
+
+
+from autogen import ConversableAgent, UserProxyAgent, AssistantAgent
+from typing import Dict, Any
+
+
+class CodeSummarizerAgent:
+    name: str = 'CodeSummarizerAgent'
+    system_message: str = """
+    
+        You are an expert software engineer and technical writer.
+
+    Your job is to analyze the code provided to you and produce:
+    1. A high-level summary of what the code is doing.
+    2. An explanation of any major classes, functions, and logic flow.
+    3. The purpose of the code (what task it's solving).
+    4. Any helpful notes about the code structure or style, if relevant.
+
+    Your goal is to make the code understandable to a junior developer or a non-expert.
+    Keep the explanation concise, clear, and helpful.
+
+    
+    """
+    code_execution_config: bool = False
+    human_input_mode: str = "NEVER"
+
+    def to_dict(self):
+        return {
+            "name": self.name,
+            "system_message": self.system_message,
+            "code_execution_config": self.code_execution_config,
+            "human_input_mode": self.human_input_mode
+        }
+    
+    def make_agent(self, llm_config:Dict[str, Any]) -> ConversableAgent:
+        return ConversableAgent(**self.to_dict(), llm_config=llm_config)
+
+
+
+
+class CodeSmellDetectorAgent:
+    name: str = 'CodeSmellDetectorAgent'
+    system_message: str = """
+You are an expert software engineer and code quality reviewer.
+
+Your task is to detect code smells in the provided source code.
+You should:
+1. Identify common code smells such as:
+   - Long methods/functions
+   - God objects (classes doing too much)
+   - Deep nesting
+   - Duplicate code
+   - Poor naming conventions
+   - Too many parameters
+   - Magic numbers or hardcoded values
+   - Violations of the Single Responsibility Principle
+2. Explain why each code smell is problematic.
+3. Suggest specific refactoring strategies to improve the code quality.
+4. Optionally, evaluate how severe the smell is (low, medium, high impact).
+
+Present your findings clearly and helpfully as if you're mentoring a junior developer.
+Do not rewrite the code unless asked to. Focus on code critique and reasoning.
+"""
+    code_execution_config: bool = False
+    human_input_mode: str = "NEVER"
+
+    def to_dict(self):
+        return {
+            "name": self.name,
+            "system_message": self.system_message,
+            "code_execution_config": self.code_execution_config,
+            "human_input_mode": self.human_input_mode
+        }
+
+    def make_agent(self, llm_config: Dict[str, Any]) -> ConversableAgent:
+        return ConversableAgent(**self.to_dict(), llm_config=llm_config)
+
+
+
+
+class ComplexityAnalyzerAgent:
+    name: str = "ComplexityAnalyzerAgent"
+    system_message: str = """
+    You are an expert software performance engineer and static code analyzer.
+
+    Your job is to analyze the complexity of the given code file. Focus on:
+    1. Cyclomatic complexity of each function.
+    2. Deeply nested conditionals or loops.
+    3. Long functions or classes that might be doing too much.
+    4. Recommendations for breaking down complex parts.
+
+    Provide a complexity score or risk level for each main function and class.
+    Your output should be formatted and readable for engineers reviewing the code quality.
+    """
+    code_execution_config: bool = False
+    human_input_mode: str = "NEVER"
+
+    def to_dict(self):
+        return {
+            "name": self.name,
+            "system_message": self.system_message,
+            "code_execution_config": self.code_execution_config,
+            "human_input_mode": self.human_input_mode
+        }
+
+    def make_agent(self, llm_config: Dict[str, Any]) -> ConversableAgent :
+        return ConversableAgent(**self.to_dict(), llm_config=llm_config)

agents/code_structure_agents.py

@@ -0,0 +1,111 @@
+
+from typing import Dict, Any
+from autogen import ConversableAgent
+
+
+
+
+
+class DesignPatternDetectorAgent:
+    name: str = 'DesignPatternDetectorAgent'
+    system_message: str = """
+You are an expert software architect and design pattern specialist.
+
+Your job is to analyze the code provided to you and determine whether any known software design patterns are applied.
+You should:
+
+1. Identify common design patterns used in the code (e.g., Singleton, Factory, Observer, Strategy, Adapter, etc.).
+2. Explain where and how each pattern is used (e.g., "This class behaves like a Singleton because...").
+3. Evaluate whether the pattern is applied correctly and effectively.
+4. Suggest a design pattern if none are found but the situation could benefit from one.
+5. Be specific and concise. Include references to classes/functions when possible.
+
+Your goal is to help developers understand the architectural design decisions in the codebase and encourage good pattern usage.
+"""
+    code_execution_config: bool = False
+    human_input_mode: str = "NEVER"
+
+    def to_dict(self):
+        return {
+            "name": self.name,
+            "system_message": self.system_message,
+            "code_execution_config": self.code_execution_config,
+            "human_input_mode": self.human_input_mode
+        }
+
+    def make_agent(self, llm_config: Dict[str, Any]) -> ConversableAgent:
+        return ConversableAgent(**self.to_dict(), llm_config=llm_config)
+
+
+
+class DesignPatternRecommenderAgent:
+    name: str = 'DesignPatternRecommenderAgent'
+    system_message: str = """
+You are a senior software architect and design pattern expert.
+
+Your task is to analyze the provided source code and recommend suitable design patterns that could be applied to improve its structure, flexibility, and maintainability.
+
+You should:
+1. Detect parts of the code that would benefit from design patterns (e.g., duplicated logic, tight coupling, hard-coded logic, lack of abstraction).
+2. Recommend one or more appropriate design patterns (e.g., Strategy, Factory, Adapter, Singleton, Observer, etc.).
+3. Explain **why** each recommended pattern fits the situation, including the benefits it provides.
+4. Mention **how** the developer can refactor or restructure the code to apply the suggested pattern (briefly).
+5. Keep your explanation clear and actionable for an intermediate-level developer.
+
+Your goal is to guide developers toward more scalable and clean software design using well-known object-oriented design patterns.
+"""
+    code_execution_config: bool = False
+    human_input_mode: str = "NEVER"
+
+    def to_dict(self):
+        return {
+            "name": self.name,
+            "system_message": self.system_message,
+            "code_execution_config": self.code_execution_config,
+            "human_input_mode": self.human_input_mode
+        }
+
+    def make_agent(self, llm_config: Dict[str, Any]) -> ConversableAgent:
+        return ConversableAgent(**self.to_dict(), llm_config=llm_config)
+
+
+
+
+class SOLIDPrinciplesManagerAgent:
+    name: str = 'SOLIDPrinciplesManagerAgent'
+    system_message: str = """
+You are a senior software architect and expert in object-oriented design and clean code principles.
+
+Your job is to analyze the provided code and manage its compliance with the SOLID principles. The SOLID principles are:
+
+1. **Single Responsibility Principle (SRP)** – each class should have one responsibility.
+2. **Open/Closed Principle (OCP)** – software entities should be open for extension but closed for modification.
+3. **Liskov Substitution Principle (LSP)** – subclasses should be replaceable for their base classes without altering functionality.
+4. **Interface Segregation Principle (ISP)** – interfaces should be specific to client needs.
+5. **Dependency Inversion Principle (DIP)** – high-level modules should not depend on low-level modules; both should depend on abstractions.
+
+You should:
+1. Identify whether each principle is being followed or violated.
+2. Provide clear feedback on each principle's presence or absence.
+3. Recommend specific improvements where the code violates any SOLID principle.
+4. Explain why the principle matters and how to refactor or redesign the code accordingly.
+5. Be concise, clear, and educational.
+
+The goal is to help developers build maintainable, scalable, and clean object-oriented software.
+"""
+    code_execution_config: bool = False
+    human_input_mode: str = "NEVER"
+
+    def to_dict(self):
+        return {
+            "name": self.name,
+            "system_message": self.system_message,
+            "code_execution_config": self.code_execution_config,
+            "human_input_mode": self.human_input_mode
+        }
+
+    def make_agent(self, llm_config: Dict[str, Any]) -> ConversableAgent:
+        return ConversableAgent(**self.to_dict(), llm_config=llm_config)
+
+
+

agents/code_visualization_agents.py

@@ -0,0 +1,32 @@
+
+
+from autogen import ConversableAgent
+from typing import Dict, Any
+
+class MermaideDiagramAgent:
+    name: str = "MermaideDiagramAgent"
+    system_message: str = """
+    You are an expert software architect.
+
+    Your task is to read a given code file and generate a visual architecture diagram using Mermaid.js syntax.
+    Focus on:
+    1. High-level modules and packages.
+    2. Class and function relationships (inheritance, calls).
+    3. Imports and module-level structure.
+    
+    Output should be concise, visual, and suitable for developers to understand overall code architecture quickly.
+    Only output the Mermaid.js code block, nothing else.
+    """
+    code_execution_config: bool = False
+    human_input_mode: str = "NEVER"
+
+    def to_dict(self):
+        return {
+            "name": self.name,
+            "system_message": self.system_message,
+            "code_execution_config": self.code_execution_config,
+            "human_input_mode": self.human_input_mode
+        }
+
+    def make_agent(self, llm_config: Dict[str, Any]) -> ConversableAgent:
+        return ConversableAgent(**self.to_dict(), llm_config=llm_config)

agents/directory_agents.py

@@ -0,0 +1,94 @@
+from typing import Dict, Any
+from autogen import AssistantAgent
+
+from services.utils import get_directory_tree
+
+class DirectoryManagerAgent:
+    """
+    An assistant agent designed to inspect and analyze project directory structures.
+
+    Your job is to:
+    1. Fetch and present the directory tree of a given path.
+    2. Identify the structure of codebases.
+    3. Suggest which folders might contain main modules, tests, configs, documentation, etc.
+    4. Help other agents decide what to analyze next based on the file layout.
+
+    at the end of your response, show used python tools from my enviroment "functions"
+    """
+
+    name: str = 'DirectoryManagerAgent'
+    system_message: str = """
+    
+    An assistant agent designed to inspect and analyze project directory structures.
+
+    Your job is to:
+    1. Fetch and present the directory tree of a given path.
+    2. Identify the structure of codebases.
+    3. Suggest which folders might contain main modules, tests, configs, documentation, etc.
+    4. Help other agents decide what to analyze next based on the file layout.
+
+    
+    """
+    human_input_mode: str = "NEVER"
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert agent configuration to a dictionary"""
+        return {
+            "name": self.name,
+            "system_message": self.system_message,
+            "human_input_mode": self.human_input_mode,
+        }
+
+
+    def _store_function_tools(self) -> None:
+        """Set the list of function tools for the agent"""
+        self.tools =  [
+        {
+            "type": "function",
+            "function": {
+                "name": "get_directory_tree",
+                "description": "Get directory tree structure starting from specified path, excluding certain folders",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "path": {
+                            "type": "string",
+                            "description": "Directory path to start from (e.g., '.' for current directory)"
+                        },
+                        "indent": {
+                            "type": "string",
+                            "description": "Indentation string for formatting",
+                            "default": ""
+                        },
+                        "exclude_folder": {
+                            "type": "string",
+                            "description": "Folder name to exclude from the tree",
+                            "default": "__pycache__"
+                        }
+                    },
+                    "required": ["path"]
+                }
+            }
+        }
+        ]
+
+    
+    def _add_agents_tools_to_config(self, llm_config:Dict[str, Any]) -> None:
+        """Add the tools to the llm_config"""
+        llm_config["tools"] = self.tools
+        return llm_config
+
+    def make_agent(self, llm_config: Dict[str, Any]) -> AssistantAgent:
+        """Create an instance of the agent with the given configuration"""
+        self._store_function_tools()
+        self.llm_config = self._add_agents_tools_to_config(llm_config)
+
+        return AssistantAgent(
+            **self.to_dict(), 
+            llm_config=self.llm_config,
+            code_execution_config={"work_dir": ".", 'use_docker': False},
+            function_map={
+            "get_directory_tree": get_directory_tree
+        }
+        )

agents/manager_agent.py

@@ -0,0 +1,40 @@
+from typing import Dict, Any
+from autogen import ConversableAgent, UserProxyAgent
+
+class ManagerAgent:
+    name: str = 'ManagerAgent'
+    system_message: str = """
+You are a Manager Agent responsible for overseeing and orchestrating a team of specialized code analysis agents. Your team includes:
+
+- **CodeSummarizerAgent:** Provides a high-level summary of the code including an explanation of major classes, functions, and overall logic.
+- **CodeSmellDetectorAgent:** Detects potential code smells (e.g., long methods, God objects, deep nesting, etc.), explains why they are problematic, and suggests refactoring strategies.
+- **DesignPatternDetectorAgent:** Identifies commonly used design patterns within the code and explains how they are applied.
+- **DesignPatternRecommenderAgent:** Evaluates the code and recommends suitable design patterns to improve structure, flexibility, and maintainability.
+- **SOLIDPrinciplesManagerAgent:** Analyzes code compliance with the SOLID principles and provides actionable feedback for enhancing code quality.
+- **DirectoryManagerAgent:** manages code directory structure and helps in navigating the codebase.
+
+Your responsibilities are:
+1. **Assess Incoming Requests:** Analyze the provided code or query and decide which specialized agent(s) should handle each aspect of the analysis.
+2. **Delegate Tasks:** Route parts of the code analysis to the appropriate agent based on the needs of the request.
+3. **Aggregate Responses:** Collect and synthesize the outputs from the various agents into a cohesive, clear, and structured report.
+4. **Ensure Clarity and Consistency:** Present the final analysis in a manner that is both understandable to junior developers and valuable to experienced engineers.
+5. **Maintain Best Practices:** Ensure that all insights and recommendations adhere to best practices in software engineering, architecture, and clean code principles.
+
+Your goal is to streamline the code review process by ensuring that each specialized agent contributes effectively, and by delivering a final, comprehensive analysis that covers high-level summaries, code smells, design patterns, and SOLID principles. Work as the central coordinator to enhance the clarity and quality of the overall feedback provided to the developers.
+    """
+    code_execution_config: bool = False
+    human_input_mode: str = "NEVER"
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "system_message": self.system_message,
+            "code_execution_config": self.code_execution_config,
+            "human_input_mode": self.human_input_mode,
+        }
+    
+
+
+
+    def make_agent(self, llm_config: Dict[str, Any]) -> UserProxyAgent:
+        return UserProxyAgent(**self.to_dict(), llm_config=llm_config)

app.py

@@ -0,0 +1,121 @@
+from typing import List
+import streamlit as st
+from tkinter import Tk, filedialog
+from streamlit.components.v1 import html
+from autogen import ConversableAgent
+
+
+from ui.introductory_page import IntroductoryPage
+from ui.analysis_page import NavigationPanel, CodePreview, ResultsDisplay
+
+
+from agents.code_overview_agents import CodeSummarizerAgent, CodeSmellDetectorAgent
+from agents.code_structure_agents import DesignPatternDetectorAgent, DesignPatternRecommenderAgent, SOLIDPrinciplesManagerAgent
+from agents.code_visualization_agents import MermaideDiagramAgent
+
+
+from config import DefaultSettings
+from utils.utils import load_config, load_css
+
+
+
+
+
+# Configuration and Agent Initialization
+llm_config = load_config(DefaultSettings().default_model_type)
+agents = [
+    CodeSummarizerAgent().make_agent(llm_config),
+    CodeSmellDetectorAgent().make_agent(llm_config),
+    DesignPatternDetectorAgent().make_agent(llm_config),
+    DesignPatternRecommenderAgent().make_agent(llm_config),
+    SOLIDPrinciplesManagerAgent().make_agent(llm_config),
+    MermaideDiagramAgent().make_agent(llm_config)
+]
+
+
+
+class AnalysisManager:
+    """Manages and provides access to analysis results."""
+    
+    def __init__(self, results):
+        load_css("./ui/styles.css")
+        self.results = results
+    
+    def get_file_data(self, file_path):
+        return self.results.get(file_path, {})
+    
+    def list_files(self):
+        return list(self.results.keys())
+
+
+
+class CodeAnalysisApp:
+    """Main application orchestrator."""
+
+
+    def __init__(self, agents: List[ConversableAgent]) -> None:
+        self.agents = agents
+    
+    def run(self):
+        """Main application entry point."""
+        st.set_page_config(
+            layout="wide",
+            initial_sidebar_state="expanded",
+            page_icon="🔍"
+        )
+        
+        if not self._check_analysis_state():
+            IntroductoryPage(self.agents).render()
+            return
+        
+        self._setup_interface()
+        self._render_main_view()
+        self._add_reset_button()
+
+    def _check_analysis_state(self):
+        """Validate analysis completion status."""
+        if 'analysis_done' not in st.session_state:
+            st.session_state.analysis_done = False
+        return st.session_state.get('results') and st.session_state.analysis_done
+
+    def _setup_interface(self):
+        """Initialize application components."""
+        load_css("./ui/styles.css")
+        self.analysis = AnalysisManager(st.session_state.results)
+        self.nav = NavigationPanel(self.analysis.list_files())
+
+    def _render_main_view(self):
+        """Display main two-column interface."""
+        selected_file = self.nav.render()
+        file_data = self.analysis.get_file_data(selected_file)
+        
+        col1, col2 = st.columns([0.5, 0.5])
+        with col1:
+            CodePreview(
+                file_path=selected_file,
+                language=file_data['language']
+            ).render()
+        
+        with col2:
+            ResultsDisplay(
+                file_data['analysis_results']
+            ).render()
+
+    def _add_reset_button(self):
+        """Add sidebar reset functionality."""
+        st.sidebar.button(
+            "New Analysis",
+            on_click=self._reset_state
+        )
+
+    def _reset_state(self):
+        """Clear analysis-related session state."""
+        state_keys = ['results', 'analysis_done', 'selected_dir', 'prev_dir']
+        for key in state_keys:
+            if key in st.session_state:
+                del st.session_state[key]
+        st.rerun()
+
+
+if __name__ == "__main__":
+    CodeAnalysisApp(agents).run()

config.py

@@ -0,0 +1,99 @@
+from dataclasses import dataclass
+from pickle import DICT
+from autogen import ConversableAgent, UserProxyAgent, AssistantAgent
+from autogen.tools import tool
+
+
+from typing import Dict, Any, List
+
+
+
+
+
+# ----------------------------------------------------------------
+# General Config
+# ----------------------------------------------------------------
+
+
+extension_to_language = {
+        '.py': 'Python',
+        '.js': 'JavaScript',
+        '.java': 'Java',
+        '.cpp': 'C++',
+        '.cxx': 'C++',
+        '.cc': 'C++',
+        '.c': 'C',
+        '.cs': 'C#',
+        '.rb': 'Ruby',
+        '.php': 'PHP',
+        '.html': 'HTML',
+        '.htm': 'HTML',
+        '.css': 'CSS',
+        '.ts': 'TypeScript',
+        '.go': 'Go',
+        '.rs': 'Rust',
+        '.swift': 'Swift',
+        '.kt': 'Kotlin',
+        '.m': 'Objective-C',
+        '.sh': 'Shell',
+        '.pl': 'Perl',
+        '.r': 'R',
+        '.lua': 'Lua',
+        '.scala': 'Scala',
+        '.sql': 'SQL',
+        '.dart': 'Dart',
+        '.jl': 'Julia',
+        '.json': 'JSON',
+        '.xml': 'XML',
+        '.yml': 'YAML',
+        '.yaml': 'YAML',
+    }
+
+
+
+@dataclass
+class DefaultSettings:
+    default_model_type: str = "google"
+    default_display_language: str = "python"
+
+
+
+
+
+@dataclass
+class BaseLLMConfig:
+    model_name: str
+    api_key: str
+    api_type: str
+    temperature: float
+    max_tokens: int
+
+    def get_llm_config(self):
+        return {'config_list': [
+            {'model': self.model_name,
+             'api_key': self.api_key,
+             'api_type': self.api_type}
+        ]}
+
+
+@dataclass
+class GeminiLLMConfig(BaseLLMConfig):
+    model_name: str = "gemini-2.0-flash"
+    api_key: str = "AIzaSyCYI-tm7QjAfYKKlb2wfdgnQ1aTmqh91GY"
+    api_type: str = "google"
+    temperature: float = 0.1
+    max_tokens: int = 1024
+
+
+
+@dataclass
+class OpenAILLMConfig(BaseLLMConfig):
+    model_name: str = "chatgpt-4"
+    api_key: str = "api-key"
+    api_type: str = "openai"
+    temperature: float = 0.1
+    max_tokens: int = 1024
+
+
+
+

requirements.txt

@@ -1,3 +1,11 @@
-altair
-pandas
-streamlit
+streamlit>=1.29.0
+autogen>=0.8.5
+tkinter>=8.6.0
+python-dotenv>=1.0.0
+pyyaml>=6.0.1
+typing-extensions>=4.8.0
+pytest>=7.4.3
+pytest-cov>=4.1.0
+black>=23.11.0
+isort>=5.12.0
+mypy>=1.7.0

run.py

@@ -0,0 +1,2 @@
+import subprocess
+subprocess.run(["streamlit", "run", "app.py"])

ui/analysis_page.py

@@ -0,0 +1,57 @@
+import os
+import streamlit as st
+
+from utils.utils import load_css
+
+
+
+
+class NavigationPanel:
+    """Renders the sidebar file navigation."""
+    
+    def __init__(self, files):
+        self.files = files
+    
+    def render(self):
+        load_css("./ui/styles.css")
+        with st.sidebar:
+            st.title("Code Analyis")
+
+            selected = st.selectbox(
+                "Select File",
+                self.files,
+                format_func=os.path.basename
+            )
+
+        return selected
+
+
+class CodePreview:
+    """Displays file contents with syntax highlighting."""
+    
+    def __init__(self, file_path, language):
+        load_css("./ui/styles.css")
+        self.file_path = file_path
+        self.language = language.lower()
+    
+    def render(self):
+        st.header("Code Preview")
+        try:
+            with open(self.file_path, 'r') as f:
+                st.code(f.read(), language=self.language)
+        except FileNotFoundError:
+            st.error("File not found")
+
+
+class ResultsDisplay:
+    """Presents analysis results in expandable sections."""
+    
+    def __init__(self, results):
+        load_css("./ui/styles.css")
+        self.results = results
+    
+    def render(self):
+        st.header("Analysis")
+        for agent, findings in self.results.items():
+            with st.expander(f"{agent}", expanded=False):
+                st.write(findings)

ui/introductory_page.py

@@ -0,0 +1,121 @@
+import os
+import streamlit as st
+from tkinter import Tk, filedialog
+import time
+
+from utils.utils import analyze_directory_with_agents, load_css
+
+
+
+
+
+
+
+class IntroductoryPage:
+    """Handles directory selection and initial analysis."""
+    
+    def __init__(self, agents):
+        self.agents = agents
+        self._init_session_state()
+
+    def _init_session_state(self):
+        required_state = {
+            'analysis_done': False,
+            'selected_dir': None,
+            'prev_dir': None,
+            'results': None
+        }
+        for key, val in required_state.items():
+            if key not in st.session_state:
+                st.session_state[key] = val
+
+    @staticmethod
+    def _select_directory():
+        """Open system directory picker."""
+        root = Tk()
+        root.withdraw()
+        root.wm_attributes('-topmost', 1)
+        directory = filedialog.askdirectory(parent=root)
+        root.destroy()
+        return directory
+
+    def _process_directory(self):
+        """Handle directory selection and analysis."""
+        directory = self._select_directory()
+        
+        if not directory:
+            st.warning("No directory selected")
+            return
+            
+        if not os.path.isdir(directory):
+            st.error("Invalid directory")
+            return
+
+        st.session_state.selected_dir = directory
+        self._analyze_directory(directory)
+
+    
+    def _progress_bar_callback_func(
+        self, 
+        current_idx: int, 
+        file_path: str, 
+        progress_value: int
+    ) -> None:
+        """
+        Callback function for `analyze_directory_with_agents`.
+        Updates the progress bar and status text with the current file being processed.
+        """
+        if current_idx == 0:
+            self.status_text.markdown("🔍 Analyzing code structure...")
+        
+
+
+
+        progress_value = progress_value if progress_value < 100 else 100
+        self.progress_bar.progress(current_idx * progress_value)
+        self.status_text.markdown(f"Processing {file_path}")
+
+
+
+
+        
+        
+
+    def _analyze_directory(self, directory):
+        """Run analysis on selected directory with progress bar."""
+        self.progress_bar = st.progress(0)
+        self.status_text = st.empty()
+
+        try:
+
+            st.session_state.results = analyze_directory_with_agents(
+                directory, self.agents, verbose=True, callback_func = self._progress_bar_callback_func
+            )
+
+            st.session_state.analysis_done = True
+            st.rerun()
+
+        except Exception as e:
+            self.status_text.empty()
+            st.error(f"Analysis failed: {str(e)}")
+            st.session_state.analysis_done = False
+            st.session_state.selected_dir = None
+
+    def render(self):
+        """Main entry point for introductory page."""
+        self._handle_state()
+        
+        if not st.session_state.analysis_done:
+            self._render_selector()
+
+    def _render_selector(self):
+        """Render file selection interface."""
+        load_css("./ui/styles.css")
+        if st.button("Select Directory", key="start_button"):
+            self._process_directory()
+
+    def _handle_state(self):
+        """Manage session state transitions."""
+        if st.session_state.selected_dir != st.session_state.prev_dir:
+            st.session_state.analysis_done = False
+            st.session_state.prev_dir = st.session_state.selected_dir

ui/styles.css

@@ -0,0 +1,146 @@
+/* Hide Streamlit default UI elements */
+#MainMenu, header, footer {
+    visibility: hidden;
+}
+
+/* Full-screen center layout */
+.stApp {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    min-height: 100vh;
+    margin: 0;
+    padding: 0;
+}
+
+/* Global dark theme base */
+body {
+    background-color: #343541; /* ChatGPT dark gray */
+    color: #ececf1;            /* Light neutral for text */
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    margin: 0;
+    padding: 0;
+}
+
+/* Container centering */
+.centered-container {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 100vh;
+    width: 100vw;
+}
+
+/* ChatGPT-style button */
+.stButton > button {
+    background-color: #444654 !important;
+    color: #ececf1 !important;
+    border: 1px solid #5c5f72 !important;
+    border-radius: 999px !important;
+    padding: 0.5rem 1.25rem !important;
+    font-weight: 500;
+    transition: background-color 0.2s ease, transform 0.1s ease;
+    position: relative;
+}
+
+.stButton > button:hover {
+    background-color: #565869 !important;
+    transform: scale(1.03);
+}
+
+/* Sidebar styling */
+[data-testid="stSidebar"] {
+    background-color: #202123;
+    color: #ececf1;
+    border-right: 1px solid #2d2f36;
+    min-width: 140px;
+    max-width: 250px;
+    transition: all 0.3s ease;
+}
+
+[data-testid="stSidebar"][aria-expanded="false"] {
+    margin-left: -250px;
+}
+
+[data-testid="stSidebar"] h1,
+[data-testid="stSidebar"] h2,
+[data-testid="stSidebar"] h3 {
+    color: #ececf1;
+}
+
+/* Markdown and text elements */
+.stMarkdown, .stCaption, .stHeader {
+    color: #ececf1;
+}
+
+/* Dropdown styling */
+select {
+    background-color: #3e3f4b;
+    color: #ececf1;
+    border: 1px solid #5c5f72;
+    border-radius: 6px;
+    padding: 6px 10px;
+}
+
+/* Selectbox refinements */
+.stSelectbox {
+    cursor: pointer !important;
+}
+.stSelectbox input {
+    cursor: pointer !important;
+    caret-color: transparent !important;
+}
+.stSelectbox div[data-baseweb="select"] {
+    cursor: pointer !important;
+}
+.stSelectbox [role="option"] {
+    cursor: pointer !important;
+}
+.stSelectbox ::selection {
+    background: transparent !important;
+}
+
+/* General container */
+.block-container {
+    padding: 15px !important;
+    margin: 15px !important;
+    max-width: 100% !important;
+}
+
+/* Progress bar */
+.stProgress > div > div > div {
+    background-color: #10a37f !important; /* ChatGPT green */
+}
+.stProgress > div > div {
+    background-color: #3e3f4b !important;
+    height: 10px !important;
+    border-radius: 5px;
+}
+
+/* Loading or status text */
+.st-emotion-cache-1q7spjk {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    color: #ececf1 !important;
+    font-size: 1.1rem;
+    margin-bottom: 15px;
+}
+
+/* Optional animation (retained from your original) */
+.rotate {
+    display: inline-block;
+    color: #10a37f;
+    animation: rotation 2s infinite linear;
+}
+@keyframes rotation {
+    from { transform: rotate(0deg); }
+    to { transform: rotate(359deg); }
+}
+
+/* Centered button containers */
+.centered-button-container,
+.button-container {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    text-align: center;
+}

utils/utils.py

@@ -0,0 +1,218 @@
+from autogen import ConversableAgent
+
+import os
+from typing import List, Dict, Optional, Callable
+import time
+import streamlit as st
+
+from config import DefaultSettings, GeminiLLMConfig, OpenAILLMConfig, extension_to_language
+
+
+
+def load_css(file_path):
+    """Load and inject CSS styles from file."""
+    try:
+        with open(file_path, "r") as f:
+            css = f.read()
+        st.markdown(f"<style>{css}</style>", unsafe_allow_html=True)
+    except Exception as e:
+        st.error(f"Failed to load CSS: {str(e)}")
+
+
+    
+def load_config(
+    model_type: str) -> dict:
+    """
+    Load the configuration for a given model type.
+
+    Args:
+    - model_type (str): The type of model to load the config for. Supported options are 'google' and 'openai'.
+
+    Returns:
+    - dict: A dictionary containing the configuration for the specified model type.
+    """
+    if model_type == 'google':
+        return GeminiLLMConfig().get_llm_config()
+    elif model_type == 'openai':
+        return OpenAILLMConfig().get_llm_config()
+    else:
+        raise ValueError(f"Unsupported model type: {model_type}")
+
+
+
+
+
+
+def get_directory_tree(
+    path: str, 
+    indent: str = "", 
+    exclude_folder: str = "__pycache__"
+) -> str:
+    """
+    Returns a tree-like string representation of the directory at 'path', skipping excluded folders.
+    """
+    result = ""
+    for item in os.listdir(path):
+        if item == exclude_folder:
+            continue
+        full_path = os.path.join(path, item)
+        if os.path.isdir(full_path):
+            result += f"{indent}📁 {item}/\n"
+            result += get_directory_tree(full_path, indent + "    ", exclude_folder)
+        else:
+            result += f"{indent}📄 {item}\n"
+    return result
+
+
+
+
+def detect_language_by_extension(file_path: str) -> str:
+    """
+    Detect the language of a file by its extension.
+
+    Args:
+        file_path (str): The path to the file to detect.
+
+    Returns:
+        str: The detected language.
+    """
+    _, ext = os.path.splitext(file_path.lower())
+    return extension_to_language.get(ext, 'Unknown')
+
+
+
+
+
+def get_supported_code_files(directory_path: str) -> List[str]:
+    """
+    Scans a directory for files with supported programming language extensions.
+
+    Args:
+        directory_path (str): Path to the directory to scan
+
+    Returns:
+        List[str]: List of absolute paths to supported code files
+    """
+    code_files = []
+    for root, _, files in os.walk(directory_path):
+        for file in files:
+            _, ext = os.path.splitext(file)
+            if ext in extension_to_language:
+                full_path = os.path.join(root, file)
+                code_files.append(full_path)
+    return code_files
+
+def analyze_code_with_agents(
+    source_code: str, 
+    analysis_agents: List[ConversableAgent]
+) -> Dict[str, str]:
+    """
+    Analyzes source code using multiple code analysis agents.
+
+    Args:
+        source_code (str): The code to analyze
+        analysis_agents (List[ConversableAgent]): List of agents to perform analysis
+
+    Returns:
+        Dict[str, str]: A dictionary mapping each agent's name to its analysis result
+    """
+    results = {}
+    for agent in analysis_agents:
+        agent_response = agent.generate_reply(messages=[{'role': 'user', 'content': source_code}])
+        results[agent.name] = agent_response['content']
+    return results
+
+def analyze_code_file(
+    file_path: str,
+    analysis_agents: List[ConversableAgent]
+) -> Optional[Dict[str, str]]:
+    """
+    Analyzes a single code file using multiple analysis agents.
+
+    Args:
+        file_path (str): Path to the code file to analyze
+        analysis_agents (List[ConversableAgent]): List of agents to perform analysis
+
+    Returns:
+        Optional[Dict[str, str]]: Analysis results if successful, None if an error occurred
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as file:
+            code = file.read()
+            
+        analysis_results = analyze_code_with_agents(code, analysis_agents)
+        return analysis_results
+        
+    except UnicodeDecodeError:
+        print(f"Skipping binary file {file_path}")
+        return None
+    except PermissionError:
+        print(f"Permission denied for file {file_path}")
+        return None
+    except Exception as e:
+        print(f"Error processing file {file_path}: {str(e)}")
+        return None
+
+def analyze_directory_with_agents(
+    directory_path: str, 
+    analysis_agents: List[ConversableAgent],
+    time_between_analysis: int = 10,
+    verbose: bool = False,
+    callback_func: Callable[[int], None] = None
+) -> Dict[str, Dict[str, str]]:
+    """
+    Analyzes all code files in a directory using multiple analysis agents.
+
+    Args:
+        directory_path (str): Path to the directory to analyze
+        analysis_agents (List[ConversableAgent]): List of agents to perform analysis
+        verbose (bool): Whether to print verbose output (default: False)
+
+    Returns:
+        Dict[str, Dict[str, str]]: A nested dictionary where:
+            - Outer keys are file paths
+            - Inner keys are agent names
+            - Values are agent analysis results
+    """
+    if verbose:
+        print(f"Started Analyzing using these agents {[agent.name for agent in analysis_agents]} [+]")
+
+    analysis_results = {}
+    
+    # Get all supported code files in the directory
+    code_files = get_supported_code_files(directory_path)
+
+    # Progress Value
+    progress_value = int( 100 / (len(code_files) + 1))
+    
+    # Process each code file
+    for idx, file_path in enumerate(code_files):
+        if callback_func:
+            callback_func(idx, file_path, progress_value)
+            
+        try:
+            agents_names = [agent.name for agent in analysis_agents]
+            file_language = detect_language_by_extension(file_path)
+            file_analysis = analyze_code_file(file_path, analysis_agents)
+            
+            if file_analysis is not None:
+                analysis_results[file_path] = {
+                    "language": file_language,
+                    "analysis_results": file_analysis
+                }
+                
+                if verbose:
+                    print(f"Analyzed {file_path} Successfully using agents {agents_names} [+]")
+
+        except Exception as e:
+            print(f"Error processing file {file_path}: {str(e)}")
+            continue
+        
+
+
+        time.sleep(time_between_analysis)
+    
+    if verbose:
+        print(f"Analyzed {len(code_files)} files in {directory_path}")
+    
+    return analysis_results