Add simplified source files for Hugging Face Space

src/__init__.py

@@ -0,0 +1,5 @@
+"""
+Devika AI Assistant - A powerful AI coding assistant
+"""
+
+__version__ = "0.1.0" 

src/agents.py

@@ -0,0 +1,58 @@
+import os
+from typing import Optional
+import openai
+import anthropic
+from duckduckgo_search import DDGS
+
+class Agent:
+    def __init__(self, base_model: str = "gpt-3.5-turbo", search_engine: str = "duckduckgo"):
+        self.base_model = base_model
+        self.search_engine = search_engine
+        
+        # Initialize API clients
+        if "gpt" in base_model:
+            openai.api_key = os.getenv("OPENAI_API_KEY")
+        elif "claude" in base_model:
+            self.claude = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+
+    def execute(self, message: str, project_name: str) -> Optional[str]:
+        try:
+            # Process the message based on the selected model
+            if "gpt" in self.base_model:
+                response = self._process_with_gpt(message)
+            elif "claude" in self.base_model:
+                response = self._process_with_claude(message)
+            else:
+                response = "Unsupported model selected"
+                
+            return response
+        except Exception as e:
+            return f"Error processing message: {str(e)}"
+
+    def subsequent_execute(self, message: str, project_name: str) -> Optional[str]:
+        return self.execute(message, project_name)
+
+    def _process_with_gpt(self, message: str) -> str:
+        response = openai.chat.completions.create(
+            model=self.base_model,
+            messages=[{"role": "user", "content": message}]
+        )
+        return response.choices[0].message.content
+
+    def _process_with_claude(self, message: str) -> str:
+        message = anthropic.Message(
+            role="user",
+            content=message
+        )
+        response = self.claude.messages.create(
+            model="claude-3-opus-20240229",
+            messages=[message]
+        )
+        return response.content[0].text
+
+    def _search_web(self, query: str, num_results: int = 5) -> list:
+        if self.search_engine == "duckduckgo":
+            with DDGS() as ddgs:
+                return list(ddgs.text(query, max_results=num_results))
+        # Add support for other search engines as needed
+        return [] 

src/config.py

@@ -0,0 +1,44 @@
+import os
+import json
+from pathlib import Path
+
+class Config:
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._load_config()
+        return cls._instance
+
+    def _load_config(self):
+        self.config = {
+            "API_KEYS": {
+                "OPENAI": os.getenv("OPENAI_API_KEY", ""),
+                "ANTHROPIC": os.getenv("ANTHROPIC_API_KEY", ""),
+                "BING": os.getenv("BING_API_KEY", ""),
+                "GOOGLE_SEARCH": os.getenv("GOOGLE_API_KEY", ""),
+                "GOOGLE_SEARCH_ENGINE_ID": os.getenv("GOOGLE_SEARCH_ENGINE_ID", ""),
+            },
+            "API_ENDPOINTS": {
+                "BING": "https://api.bing.microsoft.com/v7.0/search",
+                "GOOGLE": "https://www.googleapis.com/customsearch/v1",
+            }
+        }
+        
+        # Create necessary directories
+        base_dir = Path("/code")
+        for dir_name in ["db", "logs", "projects", "screenshots", "pdfs"]:
+            (base_dir / dir_name).mkdir(exist_ok=True)
+            
+    def get_config(self):
+        return self.config
+
+    def get_bing_api_key(self):
+        return self.config["API_KEYS"]["BING"]
+
+    def get_google_search_api_key(self):
+        return self.config["API_KEYS"]["GOOGLE_SEARCH"]
+
+    def get_google_search_engine_id(self):
+        return self.config["API_KEYS"]["GOOGLE_SEARCH_ENGINE_ID"] 

src/logger.py

@@ -0,0 +1,40 @@
+import logging
+from pathlib import Path
+
+class Logger:
+    def __init__(self, filename="devika_agent.log"):
+        # Set up logging
+        self.log_dir = Path("/code/logs")
+        self.log_dir.mkdir(exist_ok=True)
+        self.log_file = self.log_dir / filename
+        
+        # Configure logging
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            handlers=[
+                logging.FileHandler(self.log_file),
+                logging.StreamHandler()
+            ]
+        )
+        self.logger = logging.getLogger("devika")
+
+    def info(self, message: str):
+        self.logger.info(message)
+
+    def error(self, message: str):
+        self.logger.error(message)
+
+    def warning(self, message: str):
+        self.logger.warning(message)
+
+    def debug(self, message: str):
+        self.logger.debug(message)
+
+def route_logger(logger):
+    def decorator(f):
+        def wrapper(*args, **kwargs):
+            logger.info(f"Route called: {f.__name__}")
+            return f(*args, **kwargs)
+        return wrapper
+    return decorator 

src/project.py

@@ -0,0 +1,34 @@
+import json
+from datetime import datetime
+from pathlib import Path
+
+class ProjectManager:
+    def __init__(self):
+        self.projects_dir = Path("/code/projects")
+        self.projects_dir.mkdir(exist_ok=True)
+        self.messages = {}
+
+    def new_message(self):
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        return {
+            "from_devika": True,
+            "message": None,
+            "timestamp": timestamp
+        }
+
+    def get_messages(self, project_name: str):
+        if project_name not in self.messages:
+            self.messages[project_name] = []
+        return self.messages[project_name]
+
+    def add_message(self, project_name: str, message: str, from_devika: bool = True):
+        if project_name not in self.messages:
+            self.messages[project_name] = []
+        
+        msg = {
+            "from_devika": from_devika,
+            "message": message,
+            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        }
+        self.messages[project_name].append(msg)
+        return msg 

src/state.py

@@ -0,0 +1,14 @@
+class AgentState:
+    def __init__(self):
+        self.states = {}
+
+    def get_latest_state(self, project_name: str):
+        return self.states.get(project_name, None)
+
+    def is_agent_completed(self, project_name: str):
+        state = self.get_latest_state(project_name)
+        return state.get("completed", True) if state else True
+
+    def is_agent_active(self, project_name: str):
+        state = self.get_latest_state(project_name)
+        return state.get("agent_is_active", False) if state else False