Update appaaa.py

appaaa.py

@@ -2,29 +2,29 @@ import os
 import time
 import random
 import logging
+import importlib.util
 from pathlib import Path
+import threading
 
 # Set up logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Define the root directory for the application
+# Define directories
 ROOT_DIR = Path(__file__).parent / "app"
 AGENTS_DIR = ROOT_DIR / "agents"
 TOOLS_DIR = ROOT_DIR / "tools"
 TOOLKIT_DIR = ROOT_DIR / "toolkit"
 AGENT_POOL_DIR = ROOT_DIR / "agent_pool"
 
-# Create directories if they do not exist
+# Create directories
 AGENTS_DIR.mkdir(parents=True, exist_ok=True)
 TOOLS_DIR.mkdir(parents=True, exist_ok=True)
 TOOLKIT_DIR.mkdir(parents=True, exist_ok=True)
 AGENT_POOL_DIR.mkdir(parents=True, exist_ok=True)
 
-# Function to generate a new agent
 def generate_agent(agent_name: str) -> str:
-    logger.info(f"Starting to generate agent: {agent_name}")
-    time.sleep(1)  # Simulate some processing time
+    logger.info(f"Generating agent: {agent_name}")
     agent_code = f"""
 class {agent_name}:
     def __init__(self):
@@ -33,50 +33,152 @@ class {agent_name}:
     def run(self):
         print("Running {agent_name}...")
 """
-    agent_file_path = AGENTS_DIR / f"{agent_name}.py"
-    with open(agent_file_path, 'w') as f:
+    agent_path = AGENTS_DIR / f"{agent_name}.py"
+    with open(agent_path, 'w') as f:
         f.write(agent_code)
-    logger.info(f"Successfully generated agent: {agent_name} at {agent_file_path}")
     
-    # Add the agent to the agent pool
-    with open(AGENT_POOL_DIR / "agent_pool.txt", 'a') as pool_file:
-        pool_file.write(f"{agent_name}\n")
+    with open(AGENT_POOL_DIR / "agent_pool.txt", 'a') as f:
+        f.write(f"{agent_name}\n")
     
-    return agent_file_path
+    return agent_path
 
-# Function to generate a new tool
 def generate_tool(tool_name: str) -> str:
-    logger.info(f"Starting to generate tool: {tool_name}")
-    time.sleep(1)  # Simulate some processing time
+    logger.info(f"Generating tool: {tool_name}")
     tool_code = f"""
 def {tool_name}():
     print("Executing tool: {tool_name}")
 """
-    tool_file_path = TOOLS_DIR / f"{tool_name}.py"
-    with open(tool_file_path, 'w') as f:
+    tool_path = TOOLS_DIR / f"{tool_name}.py"
+    with open(tool_path, 'w') as f:
         f.write(tool_code)
-    logger.info(f"Successfully generated tool: {tool_name} at {tool_file_path}")
     
-    # Add the tool to the toolkit
-    with open(TOOLKIT_DIR / "toolkit.txt", 'a') as toolkit_file:
-        toolkit_file.write(f"{tool_name}\n")
+    with open(TOOLKIT_DIR / "toolkit.txt", 'a') as f:
+        f.write(f"{tool_name}\n")
     
-    return tool_file_path
+    return tool_path
+
+def get_agents():
+    agent_pool = AGENT_POOL_DIR / "agent_pool.txt"
+    if not agent_pool.exists():
+        return []
+    with open(agent_pool, 'r') as f:
+        return [line.strip() for line in f.readlines()]
+
+def get_tools():
+    toolkit = TOOLKIT_DIR / "toolkit.txt"
+    if not toolkit.exists():
+        return []
+    with open(toolkit, 'r') as f:
+        return [line.strip() for line in f.readlines()]
+
+def display_agents():
+    agents = get_agents()
+    print("\n=== Agent Catalog ===")
+    for idx, agent in enumerate(agents, 1):
+        print(f"{idx}. {agent}")
+    print("=====================")
+    return agents
+
+def display_tools():
+    tools = get_tools()
+    print("\n=== Tool Inventory ===")
+    for idx, tool in enumerate(tools, 1):
+        print(f"{idx}. {tool}")
+    print("======================")
+    return tools
+
+def summon_agent(agent_name):
+    agent_file = AGENTS_DIR / f"{agent_name}.py"
+    if not agent_file.exists():
+        print(f"Agent {agent_name} not found!")
+        return
+    
+    try:
+        spec = importlib.util.spec_from_file_location(agent_name, agent_file)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        agent_class = getattr(module, agent_name)
+        agent_instance = agent_class()
+        agent_instance.run()
+    except Exception as e:
+        print(f"Error summoning agent: {str(e)}")
+
+def summon_tool(tool_name):
+    tool_file = TOOLS_DIR / f"{tool_name}.py"
+    if not tool_file.exists():
+        print(f"Tool {tool_name} not found!")
+        return
+    
+    try:
+        spec = importlib.util.spec_from_file_location(tool_name, tool_file)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        tool_func = getattr(module, tool_name)
+        tool_func()
+    except Exception as e:
+        print(f"Error executing tool: {str(e)}")
+
+def user_interface():
+    while True:
+        print("\nMain Menu:")
+        print("1. List Agents")
+        print("2. List Tools")
+        print("3. Summon Agent")
+        print("4. Execute Tool")
+        print("5. Exit")
+        
+        choice = input("Select an option (1-5): ").strip()
+        
+        if choice == '1':
+            display_agents()
+        elif choice == '2':
+            display_tools()
+        elif choice == '3':
+            agents = get_agents()
+            if not agents:
+                print("No agents available!")
+                continue
+            display_agents()
+            try:
+                num = int(input("Enter agent number: "))
+                if 1 <= num <= len(agents):
+                    summon_agent(agents[num-1])
+                else:
+                    print("Invalid number!")
+            except ValueError:
+                print("Please enter a valid number!")
+        elif choice == '4':
+            tools = get_tools()
+            if not tools:
+                print("No tools available!")
+                continue
+            display_tools()
+            try:
+                num = int(input("Enter tool number: "))
+                if 1 <= num <= len(tools):
+                    summon_tool(tools[num-1])
+                else:
+                    print("Invalid number!")
+            except ValueError:
+                print("Please enter a valid number!")
+        elif choice == '5':
+            os._exit(0)
+        else:
+            print("Invalid option!")
 
-# Main loop to continuously generate agents and tools
 def main():
-    logger.info("Starting the agent/tool generation process...")
+    logger.info("Starting autonomous generation system...")
+    ui_thread = threading.Thread(target=user_interface, daemon=True)
+    ui_thread.start()
+    
     while True:
-        # Randomly decide to generate an agent or a tool
         if random.choice([True, False]):
             agent_name = f"Agent{random.randint(1, 1000)}"
             generate_agent(agent_name)
         else:
             tool_name = f"Tool{random.randint(1, 1000)}"
             generate_tool(tool_name)
-
-        # Sleep for a while before generating the next agent/tool
-        time.sleep(5)  # Adjust the sleep time as needed
+        time.sleep(5)
 
 if __name__ == "__main__":
     main()