Update definitions.py

definitions.py

@@ -264,19 +264,87 @@ class QualityMetrics:
             "performance": 0.80
         }
 
+class ToolRepository:
+    """Repository for managing tools and their configurations"""
+    
+    def __init__(self):
+        self.tools = {}
+        self.default_tools = {
+            'code_analyzer': {
+                'name': 'Code Analyzer',
+                'type': 'analysis',
+                'config': {'enabled': True}
+            },
+            'test_runner': {
+                'name': 'Test Runner',
+                'type': 'testing',
+                'config': {'enabled': True}
+            },
+            'security_scanner': {
+                'name': 'Security Scanner',
+                'type': 'security',
+                'config': {'enabled': True}
+            }
+        }
+        self._initialize_default_tools()
+
+    def _initialize_default_tools(self):
+        """Initialize the repository with default tools."""
+        self.tools.update(self.default_tools)
+
+    def get_tool(self, tool_name: str) -> Optional[Dict]:
+        """Get a tool by name."""
+        return self.tools.get(tool_name)
+
+    def add_tool(self, tool_name: str, tool_config: Dict):
+        """Add a new tool to the repository."""
+        self.tools[tool_name] = tool_config
+
+    def remove_tool(self, tool_name: str):
+        """Remove a tool from the repository."""
+        if tool_name in self.tools:
+            del self.tools[tool_name]
+
+    def list_tools(self) -> List[str]:
+        """List all available tools."""
+        return list(self.tools.keys())
+
+    def get_tools_by_type(self, tool_type: str) -> List[Dict]:
+        """Get all tools of a specific type."""
+        return [
+            tool for tool in self.tools.values()
+            if tool.get('type') == tool_type
+        ]
 
 class AutonomousAgent:
     """Autonomous agent for the system."""
     def __init__(self, app):
         self.app = app
         self.workspace_manager = WorkspaceManager(workspace_dir=os.getenv('WORKSPACE_DIR', 'workspace'))
+        self.tool_manager = self._setup_tool_manager()
         self.pipeline = self._initialize_pipeline()
         self.refinement_loop = RefinementLoop(pipeline=self.pipeline)
         self.tools_repository = self._initialize_tool_repository()
         self.chat_system = ChatSystem(self)
-        self.interface = StreamlitInterface(self)  # Updated initialization
+        self.interface = StreamlitInterface(self)
 
-    def _setup_tool_manager(self):
+    def _initialize_tool_repository(self) -> ToolRepository:
+        """Initialize the tool repository."""
+        repository = ToolRepository()
+        
+        # Add any additional tool configurations here
+        repository.add_tool('custom_analyzer', {
+            'name': 'Custom Code Analyzer',
+            'type': 'analysis',
+            'config': {
+                'enabled': True,
+                'custom_rules': []
+            }
+        })
+        
+        return repository
+
+    def _setup_tool_manager(self) -> ToolManager:
         """Setup tool manager with configuration."""
         return ToolManager()
     
@@ -284,40 +352,27 @@ class AutonomousAgent:
         """Initialize the development pipeline."""
         return DevelopmentPipeline(
             workspace_manager=self.workspace_manager,
-            tool_manager=self._setup_tool_manager()
+            tool_manager=self.tool_manager
         )
 
-    def initialize_tool_repository(self, tool_repository: object) -> None:
-        """Initializes the tool repository."""
-        self._tool_repository = tool_repository
-    
-    def build_tool(self, tool_name, task):
-        """Builds a tool."""
-        tool = self.tool_repository.get_tool(tool_name)
-        if tool:
-            tool.run(task)
-            return f"{tool_name} built and ran successfully."
-        else:
-            return f"{tool_name} not found in tool repository."
-
-    def build_agent(self, agent_name, role):
-        """Builds an agent."""
-        agent = self._create_agent(agent_name, role)
-        if agent:
-            return f"{agent_name} agent built successfully."
-        else:
-            return f"{agent_name} agent creation failed."
-
-    def _create_agent(self, agent_name, role):
-        """Creates a new agent."""
-        if role == "development":
-            return DevelopmentAgent(agent_name)
-        elif role == "testing":
-            return TestingAgent(agent_name)
-        elif role == "security":
-            return SecurityAgent(agent_name)
-        else:
-            return None
+    def get_tool(self, tool_name: str) -> Optional[Dict]:
+        """Get a tool configuration by name."""
+        return self.tools_repository.get_tool(tool_name)
+
+    def add_tool(self, tool_name: str, tool_config: Dict):
+        """Add a new tool to the repository."""
+        self.tools_repository.add_tool(tool_name, tool_config)
+
+    def remove_tool(self, tool_name: str):
+        """Remove a tool from the repository."""
+        self.tools_repository.remove_tool(tool_name)
+
+    def list_available_tools(self) -> List[str]:
+        """List all available tools."""
+        return self.tools_repository.list_tools()
+
+    def get_tools_by_type(self, tool_type: str) -> List[Dict]:
+        """Get all tools of a specific type."""
 
 class DevelopmentPipeline:
     def __init__(self, workspace_manager, tool_manager):