auto-coder 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/common/core_config/agentic_mode_manager.py

@@ -0,0 +1,109 @@
+"""
+Agentic Mode management functionality.
+
+This module provides agentic_mode configuration management methods for auto-coder sessions,
+including getting, setting, and toggling the agentic_mode between plan and act.
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .models import CoreMemory
+
+
+class AgenticModeManagerMixin:
+    """Mixin class providing agentic_mode management functionality."""
+    
+    # Available modes
+    AGENTIC_MODES = ["plan", "act"]
+    DEFAULT_AGENTIC_MODE = "act"
+    
+    # These will be provided by BaseMemoryManager when mixed in
+    _memory: 'CoreMemory'
+    
+    def save_memory(self) -> None:
+        """Save memory - provided by BaseMemoryManager."""
+        ...
+    
+    def get_agentic_mode(self) -> str:
+        """
+        Get current agentic_mode status.
+        
+        Returns:
+            Current agentic_mode ("plan" or "act"), defaults to "act"
+        """
+        # Ensure conf dict exists
+        if "conf" not in self._memory.__dict__ or self._memory.conf is None:
+            self._memory.conf = {}
+        
+        # Get the value, defaulting to "act" if not set
+        mode = self._memory.conf.get("agentic_mode", self.DEFAULT_AGENTIC_MODE)
+        
+        # Validate mode
+        if mode not in self.AGENTIC_MODES:
+            mode = self.DEFAULT_AGENTIC_MODE
+            self._memory.conf["agentic_mode"] = mode
+        
+        return mode
+    
+    def set_agentic_mode(self, mode: str):
+        """
+        Set agentic_mode.
+        
+        Args:
+            mode: Mode to set ("plan" or "act")
+        """
+        if mode not in self.AGENTIC_MODES:
+            raise ValueError(f"Invalid agentic_mode: {mode}. Valid modes: {self.AGENTIC_MODES}")
+        
+        # Ensure conf dict exists
+        if "conf" not in self._memory.__dict__ or self._memory.conf is None:
+            self._memory.conf = {}
+        
+        self._memory.conf["agentic_mode"] = mode
+        self.save_memory()
+    
+    def toggle_agentic_mode(self) -> str:
+        """
+        Toggle agentic_mode between plan and act.
+        
+        Returns:
+            New mode after toggling ("plan" or "act")
+        """
+        current_mode = self.get_agentic_mode()
+        new_mode = "act" if current_mode == "plan" else "plan"
+        self.set_agentic_mode(new_mode)
+        return new_mode
+    
+    def is_agentic_plan_mode(self) -> bool:
+        """Check if current agentic_mode is plan."""
+        return self.get_agentic_mode() == "plan"
+    
+    def is_agentic_act_mode(self) -> bool:
+        """Check if current agentic_mode is act."""
+        return self.get_agentic_mode() == "act"
+    
+    def get_agentic_mode_string(self) -> str:
+        """
+        Get agentic_mode status as string for display.
+        
+        Returns:
+            Current agentic_mode ("plan" or "act")
+        """
+        return self.get_agentic_mode()
+    
+    def ensure_agentic_mode_config(self):
+        """
+        Ensure agentic_mode configuration exists with default value.
+        
+        Returns:
+            Current agentic_mode
+        """
+        if "conf" not in self._memory.__dict__ or self._memory.conf is None:
+            self._memory.conf = {}
+        
+        if "agentic_mode" not in self._memory.conf:
+            self._memory.conf["agentic_mode"] = self.DEFAULT_AGENTIC_MODE
+            self.save_memory()
+        
+        return self.get_agentic_mode()

autocoder/common/core_config/base_manager.py

@@ -0,0 +1,123 @@
+"""
+Base memory manager providing core persistence functionality.
+
+This module contains the base MemoryManager class with core functionality
+for loading, saving, and managing memory persistence.
+"""
+
+import os
+import json
+import threading
+from typing import Dict, Any, Optional
+from filelock import FileLock
+from loguru import logger
+
+from .models import CoreMemory
+
+
+class BaseMemoryManager:
+    """
+    Base memory manager providing core persistence functionality.
+    
+    This class handles:
+    - Memory persistence (load/save)
+    - File locking for thread safety
+    - Singleton pattern management
+    - Directory creation
+    """
+    
+    _instances: Dict[str, 'BaseMemoryManager'] = {}
+    _lock = threading.Lock()
+    
+    def __new__(cls, project_root: Optional[str] = None):
+        """Ensure singleton pattern for each project root."""
+        root = os.path.abspath(project_root or os.getcwd())
+        with cls._lock:
+            if root not in cls._instances:
+                instance = super().__new__(cls)
+                cls._instances[root] = instance
+            return cls._instances[root]
+    
+    def __init__(self, project_root: Optional[str] = None):
+        """
+        Initialize base memory manager.
+        
+        Args:
+            project_root: Project root directory. If None, uses current working directory.
+        """
+        # Prevent re-initialization of singleton
+        if hasattr(self, '_initialized'):
+            return
+            
+        self.project_root = os.path.abspath(project_root or os.getcwd())
+        self.base_persist_dir = os.path.join(
+            self.project_root, ".auto-coder", "plugins", "chat-auto-coder"
+        )
+        self._memory = CoreMemory()
+        self._ensure_dirs()
+        self.load_memory()
+        self._initialized = True
+    
+    @classmethod
+    def get_instance(cls, project_root: Optional[str] = None) -> 'BaseMemoryManager':
+        """
+        Get singleton instance for a project root.
+        
+        Args:
+            project_root: Project root directory. If None, uses current working directory.
+            
+        Returns:
+            BaseMemoryManager instance
+        """
+        root = os.path.abspath(project_root or os.getcwd())
+        return cls(root)
+    
+    def _ensure_dirs(self):
+        """Ensure persistence directories exist."""
+        os.makedirs(self.base_persist_dir, exist_ok=True)
+    
+    @property
+    def memory_path(self) -> str:
+        """Get memory file path."""
+        return os.path.join(self.base_persist_dir, "memory.json")
+    
+    @property
+    def lock_path(self) -> str:
+        """Get lock file path."""
+        return self.memory_path + ".lock"
+    
+    def save_memory(self):
+        """Save current memory to disk."""
+        with FileLock(self.lock_path, timeout=30):
+            with open(self.memory_path, "w", encoding="utf-8") as f:
+                json.dump(self._memory.to_dict(), f, indent=2, ensure_ascii=False)
+        
+        logger.debug(f"Memory saved to {self.memory_path}")
+    
+    def save_memory_with_new_memory(self, new_memory: Dict[str, Any]):
+        """Save new memory data to disk."""
+        with FileLock(self.lock_path, timeout=30):
+            with open(self.memory_path, "w", encoding="utf-8") as f:
+                json.dump(new_memory, f, indent=2, ensure_ascii=False)
+            # Update internal memory state while we have the lock
+            self._memory = CoreMemory.from_dict(new_memory)
+        
+        logger.debug(f"New memory saved to {self.memory_path}")
+    
+    def load_memory(self) -> CoreMemory:
+        """Load memory from disk."""
+        if os.path.exists(self.memory_path):
+            with FileLock(self.lock_path, timeout=30):
+                with open(self.memory_path, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                self._memory = CoreMemory.from_dict(data)
+                logger.debug(f"Memory loaded from {self.memory_path}")
+        return self._memory
+    
+    def get_memory(self) -> CoreMemory:
+        """Get current memory (reloads from disk)."""
+        return self.load_memory()
+    
+    def get_memory_dict(self) -> Dict[str, Any]:
+        """Get memory as dictionary."""
+        return self.get_memory().to_dict()

autocoder/common/core_config/compatibility.py

@@ -0,0 +1,151 @@
+"""
+Compatibility functions for backward compatibility.
+
+This module provides functions that maintain compatibility with
+existing code that uses the old memory management interface.
+"""
+
+import threading
+from typing import Dict, Any, Optional, TYPE_CHECKING
+from .main_manager import get_memory_manager
+
+if TYPE_CHECKING:
+    from .main_manager import MemoryManager
+
+# Global instance cache for compatibility
+_default_memory_manager: Optional['MemoryManager'] = None
+_default_memory_manager_lock = threading.Lock()
+
+
+def save_memory():
+    """Save memory (compatibility function)."""
+    global _default_memory_manager
+    with _default_memory_manager_lock:
+        if _default_memory_manager is None:
+            _default_memory_manager = get_memory_manager()
+    _default_memory_manager.save_memory()
+
+
+def save_memory_with_new_memory(new_memory: Dict[str, Any]):
+    """Save new memory (compatibility function)."""
+    global _default_memory_manager
+    with _default_memory_manager_lock:
+        if _default_memory_manager is None:
+            _default_memory_manager = get_memory_manager()
+    _default_memory_manager.save_memory_with_new_memory(new_memory)
+
+
+def load_memory() -> Dict[str, Any]:
+    """Load memory (compatibility function)."""
+    global _default_memory_manager
+    with _default_memory_manager_lock:
+        if _default_memory_manager is None:
+            _default_memory_manager = get_memory_manager()
+    return _default_memory_manager.get_memory_dict()
+
+
+def get_memory() -> Dict[str, Any]:
+    """Get memory (compatibility function)."""
+    return load_memory()
+
+
+# Mode management compatibility functions
+def get_mode() -> str:
+    """Get current mode (compatibility function)."""
+    global _default_memory_manager
+    with _default_memory_manager_lock:
+        if _default_memory_manager is None:
+            _default_memory_manager = get_memory_manager()
+    return _default_memory_manager.get_mode()
+
+
+def set_mode(mode: str):
+    """Set mode (compatibility function)."""
+    global _default_memory_manager
+    with _default_memory_manager_lock:
+        if _default_memory_manager is None:
+            _default_memory_manager = get_memory_manager()
+    _default_memory_manager.set_mode(mode)
+
+
+def cycle_mode() -> str:
+    """Cycle mode (compatibility function)."""
+    global _default_memory_manager
+    with _default_memory_manager_lock:
+        if _default_memory_manager is None:
+            _default_memory_manager = get_memory_manager()
+    return _default_memory_manager.cycle_mode()
+
+
+# Human as model management compatibility functions
+def get_human_as_model() -> bool:
+    """Get human_as_model status (compatibility function)."""
+    global _default_memory_manager
+    with _default_memory_manager_lock:
+        if _default_memory_manager is None:
+            _default_memory_manager = get_memory_manager()
+    return _default_memory_manager.get_human_as_model()
+
+
+def set_human_as_model(enabled: bool):
+    """Set human_as_model status (compatibility function)."""
+    global _default_memory_manager
+    with _default_memory_manager_lock:
+        if _default_memory_manager is None:
+            _default_memory_manager = get_memory_manager()
+    _default_memory_manager.set_human_as_model(enabled)
+
+
+def toggle_human_as_model() -> bool:
+    """Toggle human_as_model status (compatibility function)."""
+    global _default_memory_manager
+    with _default_memory_manager_lock:
+        if _default_memory_manager is None:
+            _default_memory_manager = get_memory_manager()
+    return _default_memory_manager.toggle_human_as_model()
+
+
+def get_human_as_model_string() -> str:
+    """Get human_as_model status as string (compatibility function)."""
+    global _default_memory_manager
+    with _default_memory_manager_lock:
+        if _default_memory_manager is None:
+            _default_memory_manager = get_memory_manager()
+    return _default_memory_manager.get_human_as_model_string()
+
+
+# Agentic mode management compatibility functions
+def get_agentic_mode() -> str:
+    """Get agentic_mode status (compatibility function)."""
+    global _default_memory_manager
+    with _default_memory_manager_lock:
+        if _default_memory_manager is None:
+            _default_memory_manager = get_memory_manager()
+    return _default_memory_manager.get_agentic_mode()
+
+
+def set_agentic_mode(mode: str):
+    """Set agentic_mode (compatibility function)."""
+    global _default_memory_manager
+    with _default_memory_manager_lock:
+        if _default_memory_manager is None:
+            _default_memory_manager = get_memory_manager()
+    _default_memory_manager.set_agentic_mode(mode)
+
+
+def toggle_agentic_mode() -> str:
+    """Toggle agentic_mode (compatibility function)."""
+    global _default_memory_manager
+    with _default_memory_manager_lock:
+        if _default_memory_manager is None:
+            _default_memory_manager = get_memory_manager()
+    return _default_memory_manager.toggle_agentic_mode()
+
+
+def get_agentic_mode_string() -> str:
+    """Get agentic_mode status as string (compatibility function)."""
+    global _default_memory_manager
+    with _default_memory_manager_lock:
+        if _default_memory_manager is None:
+            _default_memory_manager = get_memory_manager()
+    return _default_memory_manager.get_agentic_mode_string()

autocoder/common/core_config/config_manager.py

@@ -0,0 +1,156 @@
+"""
+Configuration management functionality.
+
+This module provides configuration management methods including
+basic configuration, batch operations, and nested configuration support.
+"""
+
+from typing import Dict, Any, List
+from .base_manager import BaseMemoryManager
+
+
+class ConfigManagerMixin:
+    """Mixin class providing configuration management functionality."""
+    
+    def get_config(self, key: str, default: Any = None) -> Any:
+        """Get configuration value."""
+        return self._memory.conf.get(key, default)
+    
+    def set_config(self, key: str, value: Any):
+        """Set configuration value."""
+        self._memory.conf[key] = value
+        self.save_memory()
+    
+    def delete_config(self, key: str) -> bool:
+        """Delete configuration value."""
+        if key in self._memory.conf:
+            del self._memory.conf[key]
+            self.save_memory()
+            return True
+        return False
+    
+    def has_config(self, key: str) -> bool:
+        """Check if configuration key exists."""
+        return key in self._memory.conf
+    
+    # Extended configuration management methods
+    def get_all_config(self) -> Dict[str, Any]:
+        """Get all configuration as a dictionary."""
+        return self._memory.conf.copy()
+    
+    def set_configs(self, config_dict: Dict[str, Any]):
+        """Set multiple configuration values at once."""
+        for key, value in config_dict.items():
+            self._memory.conf[key] = value
+        self.save_memory()
+    
+    def update_config(self, config_dict: Dict[str, Any]):
+        """Update configuration with new values (alias for set_configs)."""
+        self.set_configs(config_dict)
+    
+    def clear_config(self):
+        """Clear all configuration."""
+        self._memory.conf.clear()
+        self.save_memory()
+    
+    def get_config_keys(self) -> List[str]:
+        """Get list of all configuration keys."""
+        return list(self._memory.conf.keys())
+    
+    def get_config_count(self) -> int:
+        """Get number of configuration items."""
+        return len(self._memory.conf)
+    
+    # Nested configuration support (for keys like "model.name")
+    def get_nested_config(self, key: str, default: Any = None) -> Any:
+        """
+        Get nested configuration value using dot notation.
+        
+        Args:
+            key: Nested key like "model.name" or "database.host"
+            default: Default value if key not found
+            
+        Returns:
+            Configuration value or default
+        """
+        keys = key.split('.')
+        value = self._memory.conf
+        
+        try:
+            for k in keys:
+                value = value[k]
+            return value
+        except (KeyError, TypeError):
+            return default
+    
+    def set_nested_config(self, key: str, value: Any):
+        """
+        Set nested configuration value using dot notation.
+        
+        Args:
+            key: Nested key like "model.name" or "database.host"
+            value: Value to set
+        """
+        keys = key.split('.')
+        config = self._memory.conf
+        
+        # Navigate to the parent of the final key
+        for k in keys[:-1]:
+            if k not in config:
+                config[k] = {}
+            elif not isinstance(config[k], dict):
+                # If existing value is not a dict, replace it
+                config[k] = {}
+            config = config[k]
+        
+        # Set the final value
+        config[keys[-1]] = value
+        self.save_memory()
+    
+    def delete_nested_config(self, key: str) -> bool:
+        """
+        Delete nested configuration value using dot notation.
+        
+        Args:
+            key: Nested key like "model.name" or "database.host"
+            
+        Returns:
+            True if key was found and deleted, False otherwise
+        """
+        keys = key.split('.')
+        config = self._memory.conf
+        
+        try:
+            # Navigate to the parent of the final key
+            for k in keys[:-1]:
+                config = config[k]
+            
+            # Delete the final key
+            if keys[-1] in config:
+                del config[keys[-1]]
+                self.save_memory()
+                return True
+            else:
+                return False
+        except (KeyError, TypeError):
+            return False
+    
+    def has_nested_config(self, key: str) -> bool:
+        """
+        Check if nested configuration key exists using dot notation.
+        
+        Args:
+            key: Nested key like "model.name" or "database.host"
+            
+        Returns:
+            True if key exists, False otherwise
+        """
+        keys = key.split('.')
+        config = self._memory.conf
+        
+        try:
+            for k in keys:
+                config = config[k]
+            return True
+        except (KeyError, TypeError):
+            return False

autocoder/common/core_config/conversation_manager.py

@@ -0,0 +1,31 @@
+"""
+Conversation management functionality.
+
+This module provides methods for managing conversation history.
+"""
+
+from typing import Dict, Any, List
+from .models import ConversationList
+
+
+class ConversationManagerMixin:
+    """Mixin class providing conversation management functionality."""
+    
+    def get_conversation(self) -> ConversationList:
+        """Get conversation history."""
+        return self._memory.conversation.copy()
+    
+    def add_conversation_message(self, role: str, content: str):
+        """Add a message to conversation history."""
+        self._memory.conversation.append({"role": role, "content": content})
+        self.save_memory()
+    
+    def clear_conversation(self):
+        """Clear conversation history."""
+        self._memory.conversation = []
+        self.save_memory()
+    
+    def set_conversation(self, conversation: ConversationList):
+        """Set entire conversation history."""
+        self._memory.conversation = conversation
+        self.save_memory()

autocoder/common/core_config/exclude_manager.py

@@ -0,0 +1,72 @@
+"""
+Exclude management functionality.
+
+This module provides methods for managing excluded files and directories.
+"""
+
+from typing import List
+from .models import FileList
+
+
+class ExcludeManagerMixin:
+    """Mixin class providing exclude management functionality."""
+    
+    # ===== Exclude Files Management =====
+    def get_exclude_files(self) -> FileList:
+        """Get exclude file patterns."""
+        return self._memory.exclude_files.copy()
+    
+    def add_exclude_files(self, patterns: FileList) -> FileList:
+        """Add exclude file patterns (avoiding duplicates)."""
+        existing_patterns = set(self._memory.exclude_files)
+        new_patterns = [p for p in patterns if p not in existing_patterns]
+        if new_patterns:
+            self._memory.exclude_files.extend(new_patterns)
+            self.save_memory()
+        return new_patterns
+    
+    def remove_exclude_files(self, patterns: FileList) -> FileList:
+        """Remove exclude file patterns."""
+        removed_patterns = []
+        for pattern in patterns:
+            if pattern in self._memory.exclude_files:
+                self._memory.exclude_files.remove(pattern)
+                removed_patterns.append(pattern)
+        if removed_patterns:
+            self.save_memory()
+        return removed_patterns
+    
+    def clear_exclude_files(self):
+        """Clear all exclude file patterns."""
+        self._memory.exclude_files = []
+        self.save_memory()
+    
+    # ===== Exclude Directories Management =====
+    def get_exclude_dirs(self) -> List[str]:
+        """Get exclude directories."""
+        return self._memory.exclude_dirs.copy()
+    
+    def add_exclude_dirs(self, dirs: List[str]) -> List[str]:
+        """Add exclude directories (avoiding duplicates)."""
+        existing_dirs = set(self._memory.exclude_dirs)
+        new_dirs = [d for d in dirs if d not in existing_dirs]
+        if new_dirs:
+            self._memory.exclude_dirs.extend(new_dirs)
+            self.save_memory()
+        return new_dirs
+    
+    def remove_exclude_dirs(self, dirs: List[str]) -> List[str]:
+        """Remove exclude directories."""
+        removed_dirs = []
+        for dir_name in dirs:
+            if dir_name in self._memory.exclude_dirs:
+                self._memory.exclude_dirs.remove(dir_name)
+                removed_dirs.append(dir_name)
+        if removed_dirs:
+            self.save_memory()
+        return removed_dirs
+    
+    def clear_exclude_dirs(self):
+        """Clear all exclude directories."""
+        self._memory.exclude_dirs = []
+        self.save_memory()