Merge pull request #7 from MinimalFuture/feat-super-agent

feat: super single agent framework

Author: zhayujie

agentmesh/__init__.py

@@ -19,4 +19,44 @@
 # Setup logging when the package is imported
 setup_logging()
 
-__all__ = ['AgentTeam', 'Agent', 'LLMModel', 'Task', 'TeamResult']
+__all__ = ['AgentTeam', 'Agent', 'LLMModel', 'Task', 'TeamResult', 'set_workspace', 'get_workspace']
+
+# Global workspace configuration
+_global_workspace_root = None
+
+
+def set_workspace(workspace_root: str):
+    """
+    Set global workspace root for all agents
+
+    This should be called once at the start of your application.
+    All agents will use this workspace unless overridden.
+
+    Args:
+        workspace_root: Path to workspace root (e.g., "~/my_agents")
+
+    Example:
+        >>> import agentmesh
+        >>> agentmesh.set_workspace("~/my_agents")
+        >>> # Now all agents will use ~/my_agents as workspace root
+    """
+    global _global_workspace_root
+    _global_workspace_root = os.path.expanduser(workspace_root)
+
+    # Also update memory config
+    from agentmesh.memory import MemoryConfig, set_global_memory_config
+    config = MemoryConfig(workspace_root=_global_workspace_root)
+    set_global_memory_config(config)
+
+
+def get_workspace() -> str:
+    """
+    Get current global workspace root
+
+    Returns:
+        Current workspace root path, or default "~/agentmesh"
+    """
+    global _global_workspace_root
+    if _global_workspace_root is None:
+        return os.path.expanduser("~/agentmesh")
+    return _global_workspace_root

agentmesh/memory/__init__.py

@@ -0,0 +1,10 @@
+"""
+Memory module for AgentMesh
+
+Provides long-term memory capabilities with hybrid search (vector + keyword)
+"""
+
+from agentmesh.memory.manager import MemoryManager
+from agentmesh.memory.config import MemoryConfig, get_default_memory_config, set_global_memory_config
+
+__all__ = ['MemoryManager', 'MemoryConfig', 'get_default_memory_config', 'set_global_memory_config']

agentmesh/memory/chunker.py

@@ -0,0 +1,139 @@
+"""
+Text chunking utilities for memory
+
+Splits text into chunks with token limits and overlap
+"""
+
+from typing import List, Tuple
+from dataclasses import dataclass
+
+
+@dataclass
+class TextChunk:
+    """Represents a text chunk with line numbers"""
+    text: str
+    start_line: int
+    end_line: int
+
+
+class TextChunker:
+    """Chunks text by line count with token estimation"""
+    
+    def __init__(self, max_tokens: int = 500, overlap_tokens: int = 50):
+        """
+        Initialize chunker
+        
+        Args:
+            max_tokens: Maximum tokens per chunk
+            overlap_tokens: Overlap tokens between chunks
+        """
+        self.max_tokens = max_tokens
+        self.overlap_tokens = overlap_tokens
+        # Rough estimation: ~4 chars per token for English/Chinese mixed
+        self.chars_per_token = 4
+    
+    def chunk_text(self, text: str) -> List[TextChunk]:
+        """
+        Chunk text into overlapping segments
+        
+        Args:
+            text: Input text to chunk
+            
+        Returns:
+            List of TextChunk objects
+        """
+        if not text.strip():
+            return []
+        
+        lines = text.split('\n')
+        chunks = []
+        
+        max_chars = self.max_tokens * self.chars_per_token
+        overlap_chars = self.overlap_tokens * self.chars_per_token
+        
+        current_chunk = []
+        current_chars = 0
+        start_line = 1
+        
+        for i, line in enumerate(lines, start=1):
+            line_chars = len(line)
+            
+            # If single line exceeds max, split it
+            if line_chars > max_chars:
+                # Save current chunk if exists
+                if current_chunk:
+                    chunks.append(TextChunk(
+                        text='\n'.join(current_chunk),
+                        start_line=start_line,
+                        end_line=i - 1
+                    ))
+                    current_chunk = []
+                    current_chars = 0
+                
+                # Split long line into multiple chunks
+                for sub_chunk in self._split_long_line(line, max_chars):
+                    chunks.append(TextChunk(
+                        text=sub_chunk,
+                        start_line=i,
+                        end_line=i
+                    ))
+                
+                start_line = i + 1
+                continue
+            
+            # Check if adding this line would exceed limit
+            if current_chars + line_chars > max_chars and current_chunk:
+                # Save current chunk
+                chunks.append(TextChunk(
+                    text='\n'.join(current_chunk),
+                    start_line=start_line,
+                    end_line=i - 1
+                ))
+                
+                # Start new chunk with overlap
+                overlap_lines = self._get_overlap_lines(current_chunk, overlap_chars)
+                current_chunk = overlap_lines + [line]
+                current_chars = sum(len(l) for l in current_chunk)
+                start_line = i - len(overlap_lines)
+            else:
+                # Add line to current chunk
+                current_chunk.append(line)
+                current_chars += line_chars
+        
+        # Save last chunk
+        if current_chunk:
+            chunks.append(TextChunk(
+                text='\n'.join(current_chunk),
+                start_line=start_line,
+                end_line=len(lines)
+            ))
+        
+        return chunks
+    
+    def _split_long_line(self, line: str, max_chars: int) -> List[str]:
+        """Split a single long line into multiple chunks"""
+        chunks = []
+        for i in range(0, len(line), max_chars):
+            chunks.append(line[i:i + max_chars])
+        return chunks
+    
+    def _get_overlap_lines(self, lines: List[str], target_chars: int) -> List[str]:
+        """Get last few lines that fit within target_chars for overlap"""
+        overlap = []
+        chars = 0
+        
+        for line in reversed(lines):
+            line_chars = len(line)
+            if chars + line_chars > target_chars:
+                break
+            overlap.insert(0, line)
+            chars += line_chars
+        
+        return overlap
+    
+    def chunk_markdown(self, text: str) -> List[TextChunk]:
+        """
+        Chunk markdown text while respecting structure
+        (For future enhancement: respect markdown sections)
+        """
+        return self.chunk_text(text)

agentmesh/memory/config.py

@@ -0,0 +1,111 @@
+"""
+Memory configuration module
+
+Provides global memory configuration with simplified workspace structure
+"""
+
+import os
+from dataclasses import dataclass, field
+from typing import Optional, List
+from pathlib import Path
+
+
+@dataclass
+class MemoryConfig:
+    """Configuration for memory storage and search"""
+    
+    # Storage paths (default: ~/agentmesh)
+    workspace_root: str = field(default_factory=lambda: os.path.expanduser("~/agentmesh"))
+    
+    # Embedding config
+    embedding_provider: str = "openai"  # "openai" | "local"
+    embedding_model: str = "text-embedding-3-small"
+    embedding_dim: int = 1536
+    
+    # Chunking config
+    chunk_max_tokens: int = 500
+    chunk_overlap_tokens: int = 50
+    
+    # Search config
+    max_results: int = 10
+    min_score: float = 0.3
+    
+    # Hybrid search weights
+    vector_weight: float = 0.7
+    keyword_weight: float = 0.3
+    
+    # Memory sources
+    sources: List[str] = field(default_factory=lambda: ["memory", "session"])
+    
+    # Sync config
+    enable_auto_sync: bool = True
+    sync_on_search: bool = True
+    
+    def get_workspace(self) -> Path:
+        """Get workspace root directory"""
+        return Path(self.workspace_root)
+    
+    def get_memory_dir(self) -> Path:
+        """Get memory files directory"""
+        return self.get_workspace() / "memory"
+    
+    def get_db_path(self) -> Path:
+        """Get SQLite database path for long-term memory index"""
+        index_dir = self.get_memory_dir() / "long-term"
+        index_dir.mkdir(parents=True, exist_ok=True)
+        return index_dir / "index.db"
+    
+    def get_skills_dir(self) -> Path:
+        """Get skills directory"""
+        return self.get_workspace() / "skills"
+    
+    def get_agent_workspace(self, agent_name: Optional[str] = None) -> Path:
+        """
+        Get workspace directory for an agent
+        
+        Args:
+            agent_name: Optional agent name (not used in current implementation)
+            
+        Returns:
+            Path to workspace directory
+        """
+        return self.get_workspace()
+
+
+# Global memory configuration
+_global_memory_config: Optional[MemoryConfig] = None
+
+
+def get_default_memory_config() -> MemoryConfig:
+    """
+    Get the global memory configuration.
+    If not set, returns a default configuration.
+    
+    Returns:
+        MemoryConfig instance
+    """
+    global _global_memory_config
+    if _global_memory_config is None:
+        _global_memory_config = MemoryConfig()
+    return _global_memory_config
+
+
+def set_global_memory_config(config: MemoryConfig):
+    """
+    Set the global memory configuration.
+    This should be called before creating any MemoryManager instances.
+    
+    Args:
+        config: MemoryConfig instance to use globally
+        
+    Example:
+        >>> from agentmesh.memory import MemoryConfig, set_global_memory_config
+        >>> config = MemoryConfig(
+        ...     workspace_root="~/my_agents",
+        ...     embedding_provider="openai",
+        ...     vector_weight=0.8
+        ... )
+        >>> set_global_memory_config(config)
+    """
+    global _global_memory_config
+    _global_memory_config = config