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

autocoder/common/core_config/file_manager.py

@@ -0,0 +1,177 @@
+"""
+File and file group management functionality.
+
+This module provides methods for managing current files, file groups,
+group information, and active groups.
+"""
+
+from typing import Dict, Any, List
+from .models import FileList, GroupsDict, GroupsInfoDict
+
+
+class FileManagerMixin:
+    """Mixin class providing file and file group management functionality."""
+    
+    # ===== File Management =====
+    def get_current_files(self) -> FileList:
+        """Get current files list."""
+        return self._memory.current_files.get("files", [])
+    
+    def set_current_files(self, files: FileList):
+        """Set current files list."""
+        self._memory.current_files["files"] = files
+        self.save_memory()
+    
+    def add_files(self, files: FileList) -> FileList:
+        """Add files to current files list (avoiding duplicates)."""
+        current_files = set(self._memory.current_files.get("files", []))
+        new_files = [f for f in files if f not in current_files]
+        if new_files:
+            self._memory.current_files["files"].extend(new_files)
+            self.save_memory()
+        return new_files
+    
+    def remove_files(self, files: FileList) -> FileList:
+        """Remove files from current files list."""
+        current_files = self._memory.current_files.get("files", [])
+        removed_files = []
+        for file in files:
+            if file in current_files:
+                current_files.remove(file)
+                removed_files.append(file)
+        if removed_files:
+            self.save_memory()
+        return removed_files
+    
+    def clear_files(self):
+        """Clear all current files."""
+        self._memory.current_files["files"] = []
+        self.save_memory()
+    
+    # ===== File Groups Management =====
+    def get_file_groups(self) -> GroupsDict:
+        """Get all file groups."""
+        return self._memory.current_files.get("groups", {})
+    
+    def get_file_group(self, name: str) -> FileList:
+        """Get files in a specific group."""
+        return self._memory.current_files.get("groups", {}).get(name, [])
+    
+    def set_file_group(self, name: str, files: FileList):
+        """Set files for a group."""
+        if "groups" not in self._memory.current_files:
+            self._memory.current_files["groups"] = {}
+        self._memory.current_files["groups"][name] = files
+        self.save_memory()
+    
+    def add_file_group(self, name: str, files: FileList):
+        """Add a new file group with current files or specified files."""
+        if not files:
+            files = self.get_current_files().copy()
+        self.set_file_group(name, files)
+    
+    def delete_file_group(self, name: str) -> bool:
+        """Delete a file group."""
+        groups = self._memory.current_files.get("groups", {})
+        if name in groups:
+            del groups[name]
+            # Also remove from groups_info and current_groups
+            groups_info = self._memory.current_files.get("groups_info", {})
+            if name in groups_info:
+                del groups_info[name]
+            current_groups = self._memory.current_files.get("current_groups", [])
+            if name in current_groups:
+                current_groups.remove(name)
+            self.save_memory()
+            return True
+        return False
+    
+    def has_file_group(self, name: str) -> bool:
+        """Check if file group exists."""
+        return name in self._memory.current_files.get("groups", {})
+    
+    # ===== File Groups Info Management =====
+    def get_groups_info(self) -> GroupsInfoDict:
+        """Get all groups info."""
+        return self._memory.current_files.get("groups_info", {})
+    
+    def get_group_info(self, name: str) -> Dict[str, Any]:
+        """Get info for a specific group."""
+        return self._memory.current_files.get("groups_info", {}).get(name, {})
+    
+    def set_group_info(self, name: str, info: Dict[str, Any]):
+        """Set info for a group."""
+        if "groups_info" not in self._memory.current_files:
+            self._memory.current_files["groups_info"] = {}
+        self._memory.current_files["groups_info"][name] = info
+        self.save_memory()
+    
+    def set_group_query_prefix(self, name: str, query_prefix: str):
+        """Set query prefix for a group."""
+        info = self.get_group_info(name)
+        info["query_prefix"] = query_prefix
+        self.set_group_info(name, info)
+    
+    def get_group_query_prefix(self, name: str) -> str:
+        """Get query prefix for a group."""
+        return self.get_group_info(name).get("query_prefix", "")
+    
+    # ===== Current Active Groups Management =====
+    def get_current_groups(self) -> List[str]:
+        """Get currently active groups."""
+        return self._memory.current_files.get("current_groups", [])
+    
+    def set_current_groups(self, groups: List[str]):
+        """Set currently active groups."""
+        self._memory.current_files["current_groups"] = groups
+        self.save_memory()
+    
+    def add_current_group(self, group_name: str):
+        """Add group to current active groups."""
+        current_groups = self._memory.current_files.get("current_groups", [])
+        if group_name not in current_groups:
+            current_groups.append(group_name)
+            self.save_memory()
+    
+    def remove_current_group(self, group_name: str) -> bool:
+        """Remove group from current active groups."""
+        current_groups = self._memory.current_files.get("current_groups", [])
+        if group_name in current_groups:
+            current_groups.remove(group_name)
+            self.save_memory()
+            return True
+        return False
+    
+    def clear_current_groups(self):
+        """Clear all current active groups."""
+        self._memory.current_files["current_groups"] = []
+        self.save_memory()
+    
+    def merge_groups_to_current_files(self, group_names: List[str]) -> List[str]:
+        """Merge files from multiple groups and set as current files."""
+        merged_files = set()
+        existing_groups = []
+        missing_groups = []
+        
+        groups = self.get_file_groups()
+        for group_name in group_names:
+            if group_name in groups:
+                merged_files.update(groups[group_name])
+                existing_groups.append(group_name)
+            else:
+                missing_groups.append(group_name)
+        
+        if merged_files:
+            self.set_current_files(list(merged_files))
+            self.set_current_groups(existing_groups)
+        
+        return missing_groups
+    
+    # ===== Legacy File Group Helpers =====
+    def get_groups(self) -> GroupsDict:
+        """Get file groups (legacy method for backward compatibility)."""
+        return self.get_file_groups()
+    
+    def set_group(self, name: str, files: FileList):
+        """Set a file group (legacy method for backward compatibility)."""
+        self.set_file_group(name, files)

autocoder/common/core_config/human_as_model_manager.py

@@ -0,0 +1,129 @@
+"""
+Human as Model management functionality.
+
+This module provides human_as_model configuration management methods for auto-coder sessions,
+including getting, setting, and toggling the human_as_model status.
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .models import CoreMemory
+
+
+class HumanAsModelManagerMixin:
+    """Mixin class providing human_as_model management functionality."""
+    
+    # These will be provided by BaseMemoryManager when mixed in
+    _memory: 'CoreMemory'
+    
+    def save_memory(self) -> None:
+        """Save memory - provided by BaseMemoryManager."""
+        ...
+    
+    def get_human_as_model(self) -> bool:
+        """
+        Get current human_as_model status.
+        
+        Returns:
+            True if human_as_model is enabled, False otherwise
+        """
+        # 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 "false" if not set
+        value = self._memory.conf.get("human_as_model", "false")
+        
+        # Handle both string and boolean values
+        if isinstance(value, bool):
+            return value
+        elif isinstance(value, str):
+            return value.lower() == "true"
+        else:
+            # Convert other types to boolean
+            return bool(value)
+    
+    def set_human_as_model(self, enabled: bool):
+        """
+        Set human_as_model status.
+        
+        Args:
+            enabled: True to enable human_as_model, False to disable
+        """
+        # Ensure conf dict exists
+        if "conf" not in self._memory.__dict__ or self._memory.conf is None:
+            self._memory.conf = {}
+        
+        self._memory.conf["human_as_model"] = "true" if enabled else "false"
+        self.save_memory()
+    
+    def toggle_human_as_model(self) -> bool:
+        """
+        Toggle human_as_model status between enabled and disabled.
+        
+        Returns:
+            New status after toggling (True if enabled, False if disabled)
+        """
+        current_status = self.get_human_as_model()
+        new_status = not current_status
+        self.set_human_as_model(new_status)
+        return new_status
+    
+    def enable_human_as_model(self):
+        """Enable human_as_model mode."""
+        self.set_human_as_model(True)
+    
+    def disable_human_as_model(self):
+        """Disable human_as_model mode."""
+        self.set_human_as_model(False)
+    
+    def is_human_as_model_enabled(self) -> bool:
+        """
+        Check if human_as_model is currently enabled.
+        
+        Returns:
+            True if human_as_model is enabled, False otherwise
+        """
+        return self.get_human_as_model()
+    
+    def get_human_as_model_string(self) -> str:
+        """
+        Get human_as_model status as string.
+        
+        Returns:
+            "true" if enabled, "false" if disabled
+        """
+        return "true" if self.get_human_as_model() else "false"
+    
+    def set_human_as_model_from_string(self, value: str):
+        """
+        Set human_as_model status from string value.
+        
+        Args:
+            value: String value ("true"/"false", "1"/"0", "yes"/"no", etc.)
+        """
+        # Convert various string representations to boolean
+        if isinstance(value, str):
+            value_lower = value.lower().strip()
+            enabled = value_lower in ("true", "1", "yes", "on", "enable", "enabled")
+        else:
+            enabled = bool(value)
+        
+        self.set_human_as_model(enabled)
+    
+    def ensure_human_as_model_config(self):
+        """
+        Ensure human_as_model configuration exists with default value.
+        
+        Returns:
+            Current human_as_model status
+        """
+        if "conf" not in self._memory.__dict__ or self._memory.conf is None:
+            self._memory.conf = {}
+        
+        if "human_as_model" not in self._memory.conf:
+            self._memory.conf["human_as_model"] = "false"
+            self.save_memory()
+        
+        return self.get_human_as_model() 

autocoder/common/core_config/lib_manager.py

@@ -0,0 +1,54 @@
+"""
+Library management functionality.
+
+This module provides methods for managing libraries and their configurations.
+"""
+
+from typing import Dict, Any, Optional
+from .models import LibsDict
+
+
+class LibManagerMixin:
+    """Mixin class providing library management functionality."""
+    
+    def get_libs(self) -> LibsDict:
+        """Get all libraries."""
+        return self._memory.libs.copy()
+    
+    def add_lib(self, name: str, config: Optional[Dict[str, Any]] = None) -> bool:
+        """Add a library."""
+        if name not in self._memory.libs:
+            self._memory.libs[name] = config or {}
+            self.save_memory()
+            return True
+        return False
+    
+    def remove_lib(self, name: str) -> bool:
+        """Remove a library."""
+        if name in self._memory.libs:
+            del self._memory.libs[name]
+            self.save_memory()
+            return True
+        return False
+    
+    def has_lib(self, name: str) -> bool:
+        """Check if library exists."""
+        return name in self._memory.libs
+    
+    def set_lib_config(self, name: str, config: Dict[str, Any]):
+        """Set configuration for a library."""
+        if name in self._memory.libs:
+            self._memory.libs[name] = config
+            self.save_memory()
+    
+    def get_lib_config(self, name: str) -> Dict[str, Any]:
+        """Get configuration for a library."""
+        return self._memory.libs.get(name, {})
+    
+    def set_lib_proxy(self, proxy_url: str):
+        """Set library proxy URL."""
+        self.set_config("lib-proxy", proxy_url)
+    
+    def get_lib_proxy(self) -> str:
+        """Get library proxy URL."""
+        return self.get_config("lib-proxy", "https://github.com/allwefantasy/llm_friendly_packages")

autocoder/common/core_config/main_manager.py

@@ -0,0 +1,81 @@
+"""
+Main MemoryManager class combining all functionality.
+
+This module provides the main MemoryManager class that combines all
+functionality from the various manager mixins.
+"""
+
+from typing import Optional, cast
+from .base_manager import BaseMemoryManager
+from .config_manager import ConfigManagerMixin
+from .file_manager import FileManagerMixin
+from .exclude_manager import ExcludeManagerMixin
+from .lib_manager import LibManagerMixin
+from .conversation_manager import ConversationManagerMixin
+from .mode_manager import ModeManagerMixin
+from .human_as_model_manager import HumanAsModelManagerMixin
+from .agentic_mode_manager import AgenticModeManagerMixin
+
+
+class MemoryManager(
+    BaseMemoryManager,
+    ConfigManagerMixin,
+    FileManagerMixin,
+    ExcludeManagerMixin,
+    LibManagerMixin,
+    ConversationManagerMixin,
+    ModeManagerMixin,
+    HumanAsModelManagerMixin,
+    AgenticModeManagerMixin
+):
+    """
+    Complete memory manager for auto-coder sessions.
+    
+    This class combines all functionality from various manager mixins:
+    - BaseMemoryManager: Core persistence and singleton functionality
+    - ConfigManagerMixin: Configuration management
+    - FileManagerMixin: File and file group management
+    - ExcludeManagerMixin: Exclude patterns management
+    - LibManagerMixin: Library management
+    - ConversationManagerMixin: Conversation history management
+    - ModeManagerMixin: Mode management functionality
+    - HumanAsModelManagerMixin: Human as model configuration management
+    - AgenticModeManagerMixin: Agentic mode configuration management
+    
+    Provides thread-safe persistence of configuration and session data.
+    """
+    
+    def __init__(self, project_root: Optional[str] = None):
+        """
+        Initialize memory manager with all functionality.
+        
+        Args:
+            project_root: Project root directory. If None, uses current working directory.
+        """
+        super().__init__(project_root)
+    
+    @classmethod
+    def get_instance(cls, project_root: Optional[str] = None) -> 'MemoryManager':
+        """
+        Get memory manager instance with proper type.
+        
+        Args:
+            project_root: Project root directory. If None, uses current working directory.
+            
+        Returns:
+            MemoryManager instance
+        """
+        return cast('MemoryManager', super().get_instance(project_root))
+
+
+def get_memory_manager(project_root: Optional[str] = None) -> MemoryManager:
+    """
+    Get memory manager instance.
+    
+    Args:
+        project_root: Project root directory. If None, uses current working directory.
+        
+    Returns:
+        MemoryManager instance
+    """
+    return MemoryManager.get_instance(project_root)

autocoder/common/core_config/mode_manager.py

@@ -0,0 +1,126 @@
+"""
+Mode management functionality.
+
+This module provides mode management methods for auto-coder sessions,
+including mode setting, getting, and cycling functionality.
+"""
+
+from typing import List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .models import CoreMemory
+
+
+class ModeManagerMixin:
+    """Mixin class providing mode management functionality."""
+    
+    # Available modes in cycle order
+    MODE_CYCLE = ["normal", "auto_detect", "voice_input", "shell"]
+    DEFAULT_MODE = "normal"
+    
+    # These will be provided by BaseMemoryManager when mixed in
+    _memory: 'CoreMemory'
+    
+    def save_memory(self) -> None:
+        """Save memory - provided by BaseMemoryManager."""
+        ...
+    
+    def get_mode(self) -> str:
+        """
+        Get current operation mode.
+        
+        Returns:
+            Current mode string, defaults to "normal" if not set
+        """
+        mode = self._memory.mode
+        if not mode or mode not in self.MODE_CYCLE:
+            mode = self.DEFAULT_MODE
+            self.set_mode(mode)
+        return mode
+    
+    def set_mode(self, mode: str):
+        """
+        Set operation mode.
+        
+        Args:
+            mode: Mode to set (normal, auto_detect, voice_input, shell)
+        """
+        if mode not in self.MODE_CYCLE:
+            raise ValueError(f"Invalid mode: {mode}. Valid modes: {self.MODE_CYCLE}")
+        
+        self._memory.mode = mode
+        self.save_memory()
+    
+    def cycle_mode(self) -> str:
+        """
+        Cycle to next mode in sequence: normal -> auto_detect -> voice_input -> shell -> normal.
+        
+        Returns:
+            New mode after cycling
+        """
+        current_mode = self.get_mode()
+        
+        try:
+            current_index = self.MODE_CYCLE.index(current_mode)
+            next_index = (current_index + 1) % len(self.MODE_CYCLE)
+            new_mode = self.MODE_CYCLE[next_index]
+        except ValueError:
+            # If current mode is not in cycle, default to first mode
+            new_mode = self.MODE_CYCLE[0]
+        
+        self.set_mode(new_mode)
+        return new_mode
+    
+    def is_mode(self, mode: str) -> bool:
+        """
+        Check if current mode matches the specified mode.
+        
+        Args:
+            mode: Mode to check against
+            
+        Returns:
+            True if current mode matches, False otherwise
+        """
+        return self.get_mode() == mode
+    
+    def is_auto_detect_mode(self) -> bool:
+        """Check if current mode is auto_detect."""
+        return self.is_mode("auto_detect")
+    
+    def is_voice_input_mode(self) -> bool:
+        """Check if current mode is voice_input."""
+        return self.is_mode("voice_input")
+    
+    def is_normal_mode(self) -> bool:
+        """Check if current mode is normal."""
+        return self.is_mode("normal")
+    
+    def is_shell_mode(self) -> bool:
+        """Check if current mode is shell."""
+        return self.is_mode("shell")
+    
+    def get_available_modes(self) -> List[str]:
+        """
+        Get list of available modes.
+        
+        Returns:
+            List of available mode strings
+        """
+        return self.MODE_CYCLE.copy()
+    
+    def reset_mode_to_default(self):
+        """Reset mode to default value."""
+        self.set_mode(self.DEFAULT_MODE)
+    
+    def ensure_mode_valid(self):
+        """
+        Ensure current mode is valid, reset to default if not.
+        
+        Returns:
+            Current mode after validation
+        """
+        current_mode = self._memory.mode
+        if not current_mode or current_mode not in self.MODE_CYCLE:
+            self.reset_mode_to_default()
+            return self.DEFAULT_MODE
+        return current_mode 

autocoder/common/core_config/models.py

@@ -0,0 +1,70 @@
+"""
+Core data models for memory management.
+
+This module contains the data structures used by the memory management system.
+"""
+
+from typing import Dict, Any, List
+from dataclasses import dataclass, field
+
+
+@dataclass
+class CoreMemory:
+    """Core memory data structure for auto-coder sessions."""
+    
+    conversation: List[Dict[str, str]] = field(default_factory=list)
+    current_files: Dict[str, Any] = field(default_factory=lambda: {
+        "files": [], 
+        "groups": {}, 
+        "groups_info": {}, 
+        "current_groups": []
+    })
+    conf: Dict[str, Any] = field(default_factory=dict)
+    exclude_dirs: List[str] = field(default_factory=list)
+    exclude_files: List[str] = field(default_factory=list)
+    libs: Dict[str, Any] = field(default_factory=dict)
+    mode: str = "normal"
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "conversation": self.conversation,
+            "current_files": self.current_files,
+            "conf": self.conf,
+            "exclude_dirs": self.exclude_dirs,
+            "exclude_files": self.exclude_files,
+            "libs": self.libs,
+            "mode": self.mode,
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'CoreMemory':
+        """Create CoreMemory instance from dictionary data."""
+        # Ensure current_files has all required keys
+        current_files = data.get("current_files", {})
+        if not isinstance(current_files, dict):
+            current_files = {"files": [], "groups": {}, "groups_info": {}, "current_groups": []}
+        else:
+            current_files.setdefault("files", [])
+            current_files.setdefault("groups", {})
+            current_files.setdefault("groups_info", {})
+            current_files.setdefault("current_groups", [])
+        
+        return cls(
+            conversation=data.get("conversation", []),
+            current_files=current_files,
+            conf=data.get("conf", {}),
+            exclude_dirs=data.get("exclude_dirs", []),
+            exclude_files=data.get("exclude_files", []),
+            libs=data.get("libs", {}),
+            mode=data.get("mode", "normal"),
+        )
+
+
+# Type aliases for better code clarity
+ConfigDict = Dict[str, Any]
+FileList = List[str]
+GroupsDict = Dict[str, List[str]]
+GroupsInfoDict = Dict[str, Dict[str, Any]]
+LibsDict = Dict[str, Any]
+ConversationList = List[Dict[str, str]]