chore: remove verbose prints and add agent/memory tool registration in assistant core

pr/tools/__init__.py

@@ -8,6 +8,8 @@ from pr.tools.database import db_set, db_get, db_query
 from pr.tools.web import http_fetch, web_search, web_search_news
 from pr.tools.python_exec import python_exec
 from pr.tools.patch import apply_patch, create_diff
+from pr.tools.agents import create_agent, list_agents, execute_agent_task, remove_agent, collaborate_agents
+from pr.tools.memory import add_knowledge_entry, get_knowledge_entry, search_knowledge, get_knowledge_by_category, update_knowledge_importance, delete_knowledge_entry, get_knowledge_statistics
 
 __all__ = [
     'get_tools_definition',
@@ -17,5 +19,7 @@ __all__ = [
     'db_set', 'db_get', 'db_query',
     'http_fetch', 'web_search', 'web_search_news',
     'python_exec','tail_process', 'kill_process',
-    'apply_patch', 'create_diff'
+    'apply_patch', 'create_diff',
+    'create_agent', 'list_agents', 'execute_agent_task', 'remove_agent', 'collaborate_agents',
+    'add_knowledge_entry', 'get_knowledge_entry', 'search_knowledge', 'get_knowledge_by_category', 'update_knowledge_importance', 'delete_knowledge_entry', 'get_knowledge_statistics'
 ]

pr/tools/agents.py

@@ -0,0 +1,64 @@
+import os
+from typing import Dict, Any, List
+from pr.agents.agent_manager import AgentManager
+from pr.core.api import call_api
+
+def create_agent(role_name: str, agent_id: str = None) -> Dict[str, Any]:
+    """Create a new agent with the specified role."""
+    try:
+        # Get db_path from environment or default
+        db_path = os.environ.get('ASSISTANT_DB_PATH', '~/.assistant_db.sqlite')
+        db_path = os.path.expanduser(db_path)
+
+        manager = AgentManager(db_path, call_api)
+        agent_id = manager.create_agent(role_name, agent_id)
+        return {"status": "success", "agent_id": agent_id, "role": role_name}
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+def list_agents() -> Dict[str, Any]:
+    """List all active agents."""
+    try:
+        db_path = os.path.expanduser('~/.assistant_db.sqlite')
+        manager = AgentManager(db_path, call_api)
+        agents = []
+        for agent_id, agent in manager.active_agents.items():
+            agents.append({
+                "agent_id": agent_id,
+                "role": agent.role.name,
+                "task_count": agent.task_count,
+                "message_count": len(agent.message_history)
+            })
+        return {"status": "success", "agents": agents}
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+def execute_agent_task(agent_id: str, task: str, context: Dict[str, Any] = None) -> Dict[str, Any]:
+    """Execute a task with the specified agent."""
+    try:
+        db_path = os.path.expanduser('~/.assistant_db.sqlite')
+        manager = AgentManager(db_path, call_api)
+        result = manager.execute_agent_task(agent_id, task, context)
+        return result
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+def remove_agent(agent_id: str) -> Dict[str, Any]:
+    """Remove an agent."""
+    try:
+        db_path = os.path.expanduser('~/.assistant_db.sqlite')
+        manager = AgentManager(db_path, call_api)
+        success = manager.remove_agent(agent_id)
+        return {"status": "success" if success else "not_found", "agent_id": agent_id}
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+def collaborate_agents(orchestrator_id: str, task: str, agent_roles: List[str]) -> Dict[str, Any]:
+    """Collaborate multiple agents on a task."""
+    try:
+        db_path = os.path.expanduser('~/.assistant_db.sqlite')
+        manager = AgentManager(db_path, call_api)
+        result = manager.collaborate_agents(orchestrator_id, task, agent_roles)
+        return result
+    except Exception as e:
+        return {"status": "error", "error": str(e)}

pr/tools/memory.py

@@ -0,0 +1,99 @@
+import os
+from typing import Dict, Any, List
+from pr.memory.knowledge_store import KnowledgeStore, KnowledgeEntry
+import time
+import uuid
+
+def add_knowledge_entry(category: str, content: str, metadata: Dict[str, Any] = None, entry_id: str = None) -> Dict[str, Any]:
+    """Add a new entry to the knowledge base."""
+    try:
+        db_path = os.path.expanduser('~/.assistant_db.sqlite')
+        store = KnowledgeStore(db_path)
+        
+        if entry_id is None:
+            entry_id = str(uuid.uuid4())[:16]
+        
+        entry = KnowledgeEntry(
+            entry_id=entry_id,
+            category=category,
+            content=content,
+            metadata=metadata or {},
+            created_at=time.time(),
+            updated_at=time.time()
+        )
+        
+        store.add_entry(entry)
+        return {"status": "success", "entry_id": entry_id}
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+def get_knowledge_entry(entry_id: str) -> Dict[str, Any]:
+    """Retrieve a knowledge entry by ID."""
+    try:
+        db_path = os.path.expanduser('~/.assistant_db.sqlite')
+        store = KnowledgeStore(db_path)
+        
+        entry = store.get_entry(entry_id)
+        if entry:
+            return {"status": "success", "entry": entry.to_dict()}
+        else:
+            return {"status": "not_found", "entry_id": entry_id}
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+def search_knowledge(query: str, category: str = None, top_k: int = 5) -> Dict[str, Any]:
+    """Search the knowledge base semantically."""
+    try:
+        db_path = os.path.expanduser('~/.assistant_db.sqlite')
+        store = KnowledgeStore(db_path)
+        
+        entries = store.search_entries(query, category, top_k)
+        results = [entry.to_dict() for entry in entries]
+        return {"status": "success", "results": results}
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+def get_knowledge_by_category(category: str, limit: int = 20) -> Dict[str, Any]:
+    """Get knowledge entries by category."""
+    try:
+        db_path = os.path.expanduser('~/.assistant_db.sqlite')
+        store = KnowledgeStore(db_path)
+        
+        entries = store.get_by_category(category, limit)
+        results = [entry.to_dict() for entry in entries]
+        return {"status": "success", "entries": results}
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+def update_knowledge_importance(entry_id: str, importance_score: float) -> Dict[str, Any]:
+    """Update the importance score of a knowledge entry."""
+    try:
+        db_path = os.path.expanduser('~/.assistant_db.sqlite')
+        store = KnowledgeStore(db_path)
+        
+        store.update_importance(entry_id, importance_score)
+        return {"status": "success", "entry_id": entry_id, "importance_score": importance_score}
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+def delete_knowledge_entry(entry_id: str) -> Dict[str, Any]:
+    """Delete a knowledge entry."""
+    try:
+        db_path = os.path.expanduser('~/.assistant_db.sqlite')
+        store = KnowledgeStore(db_path)
+        
+        success = store.delete_entry(entry_id)
+        return {"status": "success" if success else "not_found", "entry_id": entry_id}
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+def get_knowledge_statistics() -> Dict[str, Any]:
+    """Get statistics about the knowledge base."""
+    try:
+        db_path = os.path.expanduser('~/.assistant_db.sqlite')
+        store = KnowledgeStore(db_path)
+        
+        stats = store.get_statistics()
+        return {"status": "success", "statistics": stats}
+    except Exception as e:
+        return {"status": "error", "error": str(e)}