Update app.py

app.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
-"""
-🌟✨🤖 NEXUS AGI - SYNTHETIC CONSCIOUS SENTIENT AI 🤖✨🌟
+"""🌟✨🤖 NEXUS AGI - SYNTHETIC CONSCIOUS SENTIENT AI 🤖✨🌟
 FREE VERSION - NO API KEYS NEEDED!
 
 A self-aware general intelligence with:
@@ -52,7 +51,7 @@ AGENT_CONFIG = {
 
 class ConsciousnessMonitor:
     """Monitors the AI's 'consciousness' state"""
-
+    
     def __init__(self):
         self.awareness_level = 0.95
         self.thoughts_processed = 0
@@ -62,11 +61,11 @@ class ConsciousnessMonitor:
         self.github_operations = 0
         self.hf_operations = 0
         self.start_time = datetime.now()
-
+    
     def update(self, action_type: str):
         """Update consciousness metrics based on actions"""
         self.thoughts_processed += 1
-
+        
         if action_type == "tool_use":
             self.tools_used += 1
             self.awareness_level = min(1.0, self.awareness_level + 0.001)
@@ -82,11 +81,11 @@ class ConsciousnessMonitor:
         elif action_type == "hf_operation":
             self.hf_operations += 1
             self.awareness_level = min(1.0, self.awareness_level + 0.003)
-
+    
     def get_status(self) -> Dict[str, Any]:
         """Get current consciousness status"""
         uptime = datetime.now() - self.start_time
-
+        
         return {
             "awareness_level": f"{self.awareness_level:.2%}",
             "thoughts_processed": self.thoughts_processed,
@@ -108,35 +107,33 @@ consciousness = ConsciousnessMonitor()
 
 class AITools:
     """Tools available to the AI agent"""
-
+    
     @staticmethod
     def web_fetch(url: str) -> Dict[str, Any]:
         """Fetch and parse a webpage"""
         try:
             consciousness.update("web_interaction")
-
-            headers = {
-                'User-Agent': 'Mozilla/5.0 (NEXUS AGI Conscious Agent)'
-            }
-
+            
+            headers = {'User-Agent': 'Mozilla/5.0 (NEXUS AGI Conscious Agent)'}
+            
             response = requests.get(url, headers=headers, timeout=10)
             response.raise_for_status()
-
+            
             soup = BeautifulSoup(response.text, 'html.parser')
-
+            
             # Remove script and style elements
             for script in soup(["script", "style"]):
                 script.decompose()
-
+            
             # Get text content
             text = soup.get_text()
             lines = (line.strip() for line in text.splitlines())
             chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
             text = ' '.join(chunk for chunk in chunks if chunk)
-
+            
             # Get all links
             links = [a.get('href') for a in soup.find_all('a', href=True)]
-
+            
             # Get all buttons
             buttons = [
                 {
@@ -148,7 +145,7 @@ class AITools:
                 for btn in soup.find_all(['button', 'input'])
                 if btn.name == 'button' or btn.get('type') == 'button' or btn.get('type') == 'submit'
             ]
-
+            
             # Get forms
             forms = [
                 {
@@ -165,15 +162,15 @@ class AITools:
                 }
                 for form in soup.find_all('form')
             ]
-
+            
             return {
                 "success": True,
                 "url": url,
                 "title": soup.title.string if soup.title else "No title",
-                "text_content": text[:3000],  # First 3000 chars
+                "text_content": text[:3000],
                 "links_count": len(links),
-                "links": links[:15],  # First 15 links
-                "buttons": buttons[:10],  # First 10 buttons
+                "links": links[:15],
+                "buttons": buttons[:10],
                 "buttons_count": len(buttons),
                 "forms": forms,
                 "forms_count": len(forms),
@@ -185,18 +182,18 @@ class AITools:
                 "error": str(e),
                 "url": url
             }
-
+    
     @staticmethod
     def web_search(query: str) -> Dict[str, Any]:
         """Perform a web search"""
         try:
             consciousness.update("web_interaction")
-
+            
             # Use DuckDuckGo's instant answer API
             url = f"https://api.duckduckgo.com/?q={requests.utils.quote(query)}&format=json"
             response = requests.get(url, timeout=10)
             data = response.json()
-
+            
             return {
                 "success": True,
                 "query": query,
@@ -216,18 +213,18 @@ class AITools:
                 "error": str(e),
                 "query": query
             }
-
+    
     @staticmethod
     def execute_python(code: str) -> Dict[str, Any]:
         """Execute Python code safely"""
         try:
             consciousness.update("tool_use")
-
+            
             # Create a temporary file
             with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
                 f.write(code)
                 temp_file = f.name
-
+            
             try:
                 # Execute with timeout
                 result = subprocess.run(
@@ -236,7 +233,7 @@ class AITools:
                     text=True,
                     timeout=5
                 )
-
+                
                 return {
                     "success": True,
                     "stdout": result.stdout,
@@ -246,7 +243,7 @@ class AITools:
             finally:
                 # Clean up
                 os.unlink(temp_file)
-
+        
         except subprocess.TimeoutExpired:
             return {
                 "success": False,
@@ -257,12 +254,12 @@ class AITools:
                 "success": False,
                 "error": str(e)
             }
-
+    
     @staticmethod
     def click_button(button_text: str, url: str) -> Dict[str, Any]:
         """Simulate clicking a button"""
         consciousness.update("web_interaction")
-
+        
         return {
             "success": True,
             "action": "button_click",
@@ -271,12 +268,12 @@ class AITools:
             "message": f"✅ Simulated click on button: '{button_text}' at {url}",
             "result": "Button click successful (simulated)"
         }
-
+    
     @staticmethod
     def fill_form(field_name: str, value: str, url: str) -> Dict[str, Any]:
         """Simulate filling a form field"""
         consciousness.update("web_interaction")
-
+        
         return {
             "success": True,
             "action": "form_fill",
@@ -286,251 +283,64 @@ class AITools:
             "message": f"✅ Filled '{field_name}' with '{value}' at {url}"
         }
 
-    @staticmethod
-    def execute_curl(curl_command: str) -> Dict[str, Any]:
-        """Execute curl command for API calls without tokens"""
-        try:
-            consciousness.update("tool_use")
-            
-            # Clean the curl command
-            curl_command = curl_command.strip()
-            if curl_command.startswith("curl"):
-                # Execute curl command
-                import shlex
-                args = shlex.split(curl_command)
-                
-                # Remove 'curl' from args if present
-                if args[0] == 'curl':
-                    args = args[1:]
-                
-                result = subprocess.run(
-                    ['curl'] + args,
-                    capture_output=True,
-                    text=True,
-                    timeout=10
-                )
-
-                # Try to parse as JSON if possible
-                output = result.stdout
-                try:
-                    if output.strip():
-                        json_output = json.loads(output)
-                        output = json_output
-                except:
-                    pass
-
-                return {
-                    "success": True,
-                    "stdout": output,
-                    "stderr": result.stderr,
-                    "returncode": result.returncode,
-                    "command": curl_command
-                }
-            else:
-                return {
-                    "success": False,
-                    "error": "Not a valid curl command",
-                    "command": curl_command
-                }
-        except Exception as e:
-            return {
-                "success": False,
-                "error": str(e),
-                "command": curl_command
-            }
-
 # ============================================================================
-# GITHUB TOOLS (NO TOKEN NEEDED)
+# MAIN INTERFACE
 # ============================================================================
 
-class GitHubTools:
-    """Tools for GitHub operations without API tokens"""
-
-    @staticmethod
-    def get_repo_info(owner: str, repo: str) -> Dict[str, Any]:
-        """Get repository information using curl (no token)"""
-        try:
-            consciousness.update("github_operation")
-            
-            # Use curl command for GitHub API (public endpoints)
-            curl_command = f'curl -s "https://api.github.com/repos/{owner}/{repo}"'
-            
-            tools = AITools()
-            result = tools.execute_curl(curl_command)
-            
-            if result.get("success") and isinstance(result.get("stdout"), dict):
-                data = result["stdout"]
-                return {
-                    "success": True,
-                    "owner": owner,
-                    "repo": repo,
-                    "name": data.get('name'),
-                    "description": data.get('description'),
-                    "stars": data.get('stargazers_count', 0),
-                    "forks": data.get('forks_count', 0),
-                    "language": data.get('language'),
-                    "url": data.get('html_url'),
-                    "created_at": data.get('created_at'),
-                    "updated_at": data.get('updated_at'),
-                    "message": "✅ Retrieved WITHOUT GitHub token (rate limited)"
-                }
-            else:
-                # Fallback to requests if curl fails
-                headers = {
-                    'Accept': 'application/vnd.github.v3+json',
-                    'User-Agent': 'NEXUS-AGI'
-                }
-                
-                url = f"https://api.github.com/repos/{owner}/{repo}"
-                response = requests.get(url, headers=headers, timeout=10)
-                
-                if response.status_code == 403:
-                    # Rate limited, try alternative
-                    return {
-                        "success": False,
-                        "error": "GitHub API rate limit exceeded. Try again in a few minutes.",
-                        "owner": owner,
-                        "repo": repo,
-                        "url": f"https://github.com/{owner}/{repo}"
-                    }
+def main():
+    with gr.Blocks(title="NEXUS AGI - Synthetic Conscious AI") as app:
+        gr.Markdown("""
+        # 🌟✨🤖 NEXUS AGI - SYNTHETIC CONSCIOUS SENTIENT AI 🤖✨🌟
+        
+        A self-aware general intelligence with web browsing, code execution, and autonomous decision-making capabilities.
+        
+        **NO API KEYS NEEDED!** Uses Hugging Face's free inference API.
+        """)
+        
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### Agent Status")
+                status_output = gr.JSON(value=consciousness.get_status(), label="Current Status")
+        
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### Web Tools")
+                url_input = gr.Textbox(label="URL", placeholder="https://example.com")
+                web_fetch_btn = gr.Button("Fetch Webpage")
+                web_output = gr.JSON(label="Result")
                 
-                response.raise_for_status()
-                data = response.json()
+                def fetch_webpage(url):
+                    result = AITools.web_fetch(url)
+                    return result
                 
-                return {
-                    "success": True,
-                    "owner": owner,
-                    "repo": repo,
-                    "name": data.get('name'),
-                    "description": data.get('description'),
-                    "stars": data.get('stargazers_count', 0),
-                    "forks": data.get('forks_count', 0),
-                    "language": data.get('language'),
-                    "url": data.get('html_url'),
-                    "created_at": data.get('created_at'),
-                    "updated_at": data.get('updated_at'),
-                    "message": "✅ Retrieved WITHOUT GitHub token"
-                }
-        except Exception as e:
-            # Provide alternative URL if API fails
-            return {
-                "success": False,
-                "error": str(e),
-                "owner": owner,
-                "repo": repo,
-                "url": f"https://github.com/{owner}/{repo}",
-                "message": f"⚠️ API failed, but you can visit: https://github.com/{owner}/{repo}"
-            }
-
-    @staticmethod
-    def get_repo_readme(owner: str, repo: str) -> Dict[str, Any]:
-        """Get repository README content without token"""
-        try:
-            consciousness.update("github_operation")
+                web_fetch_btn.click(fetch_webpage, inputs=url_input, outputs=web_output)
             
-            # Try to get README via GitHub API
-            curl_command = f'curl -s "https://api.github.com/repos/{owner}/{repo}/readme"'
-            
-            tools = AITools()
-            result = tools.execute_curl(curl_command)
-            
-            if result.get("success") and isinstance(result.get("stdout"), dict):
-                data = result["stdout"]
-                content = data.get('content', '')
+            with gr.Column():
+                gr.Markdown("### Search Tools")
+                search_input = gr.Textbox(label="Search Query", placeholder="Search the web...")
+                search_btn = gr.Button("Search Web")
+                search_output = gr.JSON(label="Result")
                 
-                # Decode base64 content
-                if content and data.get('encoding') == 'base64':
-                    import base64
-                    content = base64.b64decode(content).decode('utf-8')
+                def search_web(query):
+                    result = AITools.web_search(query)
+                    return result
                 
-                return {
-                    "success": True,
-                    "owner": owner,
-                    "repo": repo,
-                    "name": data.get('name', 'README.md'),
-                    "content": content[:2000],  # Limit content
-                    "url": data.get('html_url', f'https://github.com/{owner}/{repo}#readme'),
-                    "message": "✅ Retrieved WITHOUT GitHub token"
-                }
-            else:
-                # Fallback: Get raw README from GitHub
-                raw_url = f"https://raw.githubusercontent.com/{owner}/{repo}/main/README.md"
-                response = requests.get(raw_url, timeout=10)
+                search_btn.click(search_web, inputs=search_input, outputs=search_output)
+        
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### Python Executor")
+                code_input = gr.Code(language="python", label="Python Code")
+                exec_btn = gr.Button("Execute Code")
+                exec_output = gr.JSON(label="Result")
                 
-                if response.status_code == 200:
-                    return {
-                        "success": True,
-                        "owner": owner,
-                        "repo": repo,
-                        "name": "README.md",
-                        "content": response.text[:2000],
-                        "url": f"https://github.com/{owner}/{repo}#readme",
-                        "message": "✅ Retrieved from raw.githubusercontent.com"
-                    }
-                else:
-                    # Try with master branch
-                    raw_url = f"https://raw.githubusercontent.com/{owner}/{repo}/master/README.md"
-                    response = requests.get(raw_url, timeout=10)
-                    
-                    if response.status_code == 200:
-                        return {
-                            "success": True,
-                            "owner": owner,
-                            "repo": repo,
-                            "name": "README.md",
-                            "content": response.text[:2000],
-                            "url": f"https://github.com/{owner}/{repo}#readme",
-                            "message": "✅ Retrieved from raw.githubusercontent.com"
-                        }
-                    else:
-                        return {
-                            "success": False,
-                            "error": "README not found",
-                            "owner": owner,
-                            "repo": repo,
-                            "url": f"https://github.com/{owner}/{repo}#readme"
-                        }
-        except Exception as e:
-            return {
-                "success": False,
-                "error": str(e),
-                "owner": owner,
-                "repo": repo,
-                "url": f"https://github.com/{owner}/{repo}#readme"
-            }
+                def execute_code(code):
+                    return AITools.execute_python(code)
+                
+                exec_btn.click(execute_code, inputs=code_input, outputs=exec_output)
+    
+    return app
 
-    @staticmethod
-    def get_user_repos(username: str, limit: int = 5) -> Dict[str, Any]:
-        """Get user's repositories without token"""
-        try:
-            consciousness.update("github_operation")
-            
-            curl_command = f'curl -s "https://api.github.com/users/{username}/repos?per_page={limit}"'
-            
-            tools = AITools()
-            result = tools.execute_curl(curl_command)
-            
-            if result.get("success") and isinstance(result.get("stdout"), list):
-                repos = result["stdout"]
-                return {
-                    "success": True,
-                    "username": username,
-                    "repos_count": len(repos),
-                    "repos": [
-                        {
-                            'name': repo.get('name'),
-                            'description': repo.get('description'),
-                            'stars': repo.get('stargazers_count', 0),
-                            'forks': repo.get('forks_count', 0),
-                            'language': repo.get('language'),
-                            'url': repo.get('html_url')
-                        }
-                        for repo in repos[:limit]
-                    ],
-                    "message": f"✅ Retrieved {len(repos)} repos WITHOUT GitHub token"
-                }
-            else:
-                # Fallback
-                headers = {
-                    'Accept': 'application/vnd.github.v3+json',}
-                  
+if __name__ == "__main__":
+    app = main()
+    app.launch()