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

autocoder/common/{llm_friendly_package.py → llm_friendly_package/main_manager.py}

@@ -1,231 +1,76 @@
 """
-LLM Friendly Package Manager
+Main LLM Friendly Package Manager
 
-This module provides a class-based interface for managing LLM friendly packages,
-including operations like get, list, list_all, add, remove, refresh, etc.
+This module provides the complete package management functionality,
+integrating with the core_config module for state management.
 """
 
 import os
-import json
-from typing import List, Dict, Any, Optional, Tuple
-from dataclasses import dataclass
+from typing import List, Optional, Dict, Any
 from rich.console import Console
 from rich.table import Table
 import git
-from filelock import FileLock
+from git import GitCommandError
 
-
-@dataclass
-class LibraryInfo:
-    """Information about a library"""
-    domain: str
-    username: str
-    lib_name: str
-    full_path: str
-    is_added: bool
-    has_md_files: bool = True
-
-
-@dataclass
-class PackageDoc:
-    """Package documentation information"""
-    file_path: str
-    content: Optional[str] = None
+from autocoder.common.core_config import get_memory_manager
+from .models import LibraryInfo, LibraryList, DocsList, RepositoryInfo
 
 
 class LLMFriendlyPackageManager:
-    """Manager for LLM friendly packages"""
+    """
+    Complete LLM Friendly Package Manager
+    
+    This class provides all package management functionality including:
+    - Library management (add, remove, list)
+    - Documentation management (get docs, paths)
+    - Repository management (clone, refresh, proxy)
+    - Display management (tables, output)
+    """
     
-    def __init__(self, project_root: str = None, base_persist_dir: str = None):
+    def __init__(self, project_root: Optional[str] = None):
         """
         Initialize the package manager
         
         Args:
             project_root: Project root directory, defaults to current working directory
-            base_persist_dir: Base directory for persistence, defaults to .auto-coder/plugins/chat-auto-coder
         """
         self.project_root = project_root or os.getcwd()
-        self.base_persist_dir = base_persist_dir or os.path.join(
-            self.project_root, ".auto-coder", "plugins", "chat-auto-coder"
-        )
+        self.memory_manager = get_memory_manager(self.project_root)
+        self.console = Console()
+        
+        # Set up directory paths
         self.lib_dir = os.path.join(self.project_root, ".auto-coder", "libs")
         self.llm_friendly_packages_dir = os.path.join(self.lib_dir, "llm_friendly_packages")
-        self.console = Console()
         
         # Ensure directories exist
-        os.makedirs(self.lib_dir, exist_ok=True)
-        os.makedirs(self.base_persist_dir, exist_ok=True)
-    
-    def _get_memory_path(self) -> str:
-        """Get memory file path"""
-        return os.path.join(self.base_persist_dir, "memory.json")
+        self._ensure_dirs()
     
-    def _load_memory(self) -> Dict[str, Any]:
-        """Load memory from file"""
-        memory_path = self._get_memory_path()
-        lock_path = memory_path + ".lock"
-        
-        default_memory = {
-            "conversation": [],
-            "current_files": {"files": [], "groups": {}},
-            "conf": {},
-            "exclude_dirs": [],
-            "mode": "auto_detect",
-            "libs": {}
-        }
-        
-        if not os.path.exists(memory_path):
-            return default_memory
-            
-        try:
-            with FileLock(lock_path, timeout=30):
-                with open(memory_path, "r", encoding="utf-8") as f:
-                    memory = json.load(f)
-                    # Ensure libs key exists
-                    if "libs" not in memory:
-                        memory["libs"] = {}
-                    return memory
-        except Exception:
-            return default_memory
+    def _ensure_dirs(self):
+        """Ensure required directories exist"""
+        os.makedirs(self.lib_dir, exist_ok=True)
     
-    def _save_memory(self, memory: Dict[str, Any]) -> None:
-        """Save memory to file"""
-        memory_path = self._get_memory_path()
-        lock_path = memory_path + ".lock"
-        
-        with FileLock(lock_path, timeout=30):
-            with open(memory_path, "w", encoding="utf-8") as f:
-                json.dump(memory, f, indent=2, ensure_ascii=False)
+    @property
+    def default_proxy_url(self) -> str:
+        """Get default proxy URL"""
+        return "https://github.com/allwefantasy/llm_friendly_packages"
     
     def _get_current_proxy(self) -> str:
-        """Get current proxy URL"""
-        memory = self._load_memory()
-        return memory.get("lib-proxy", "https://github.com/allwefantasy/llm_friendly_packages")
-    
-    def _clone_repository(self) -> bool:
-        """Clone the llm_friendly_packages repository"""
-        if os.path.exists(self.llm_friendly_packages_dir):
-            return True
-            
-        self.console.print("Cloning llm_friendly_packages repository...")
-        try:
-            proxy_url = self._get_current_proxy()
-            git.Repo.clone_from(proxy_url, self.llm_friendly_packages_dir)
-            self.console.print("Successfully cloned llm_friendly_packages repository")
-            return True
-        except git.exc.GitCommandError as e:
-            self.console.print(f"Error cloning repository: {e}")
-            return False
-    
-    def get_docs(self, package_name: Optional[str] = None, return_paths: bool = False) -> List[str]:
-        """
-        Get documentation for packages
-        
-        Args:
-            package_name: Specific package name to get docs for, None for all packages
-            return_paths: If True, return file paths; if False, return file contents
-            
-        Returns:
-            List of documentation content or file paths
-        """
-        docs = []
-        
-        if not os.path.exists(self.llm_friendly_packages_dir):
-            return docs
-        
-        memory = self._load_memory()
-        libs = list(memory.get("libs", {}).keys())
-        
-        for domain in os.listdir(self.llm_friendly_packages_dir):
-            domain_path = os.path.join(self.llm_friendly_packages_dir, domain)
-            if not os.path.isdir(domain_path):
-                continue
-                
-            for username in os.listdir(domain_path):
-                username_path = os.path.join(domain_path, username)
-                if not os.path.isdir(username_path):
-                    continue
-                    
-                for lib_name in os.listdir(username_path):
-                    lib_path = os.path.join(username_path, lib_name)
-                    
-                    # Check if this is the requested package
-                    if not os.path.isdir(lib_path):
-                        continue
-                        
-                    if package_name is not None:
-                        if not (lib_name == package_name or 
-                               package_name == os.path.join(username, lib_name)):
-                            continue
-                    
-                    # Check if library is added
-                    if lib_name not in libs:
-                        continue
-                    
-                    # Collect markdown files
-                    for root, _, files in os.walk(lib_path):
-                        for file in files:
-                            if file.endswith(".md"):
-                                file_path = os.path.join(root, file)
-                                if return_paths:
-                                    docs.append(file_path)
-                                else:
-                                    try:
-                                        with open(file_path, "r", encoding="utf-8") as f:
-                                            docs.append(f.read())
-                                    except Exception as e:
-                                        self.console.print(f"Error reading {file_path}: {e}")
-        
-        return docs
+        """Get current proxy URL from memory"""
+        return self.memory_manager.get_config("lib-proxy", self.default_proxy_url)
     
-    def get_package_path(self, package_name: str) -> Optional[str]:
-        """
-        Get the full path of a package by its name
-        
-        Args:
-            package_name: Package name (can be just lib_name or username/lib_name)
-            
-        Returns:
-            Full path to the package directory, or None if not found
-        """
-        if not os.path.exists(self.llm_friendly_packages_dir):
-            return None
-        
-        for domain in os.listdir(self.llm_friendly_packages_dir):
-            domain_path = os.path.join(self.llm_friendly_packages_dir, domain)
-            if not os.path.isdir(domain_path):
-                continue
-                
-            for username in os.listdir(domain_path):
-                username_path = os.path.join(domain_path, username)
-                if not os.path.isdir(username_path):
-                    continue
-                    
-                for lib_name in os.listdir(username_path):
-                    lib_path = os.path.join(username_path, lib_name)
-                    if not os.path.isdir(lib_path):
-                        continue
-                    
-                    # Check if this matches the requested package
-                    if (lib_name == package_name or 
-                        package_name == os.path.join(username, lib_name)):
-                        return lib_path
-        
-        return None
+    # ======== Library Management ========
     
     def list_added_libraries(self) -> List[str]:
         """List all added libraries"""
-        memory = self._load_memory()
-        return list(memory.get("libs", {}).keys())
+        return list(self.memory_manager.get_libs().keys())
     
-    def list_all_available_libraries(self) -> List[LibraryInfo]:
+    def list_all_available_libraries(self) -> LibraryList:
         """List all available libraries in the repository"""
         if not os.path.exists(self.llm_friendly_packages_dir):
             return []
         
         available_libs = []
-        memory = self._load_memory()
-        added_libs = set(memory.get("libs", {}).keys())
+        added_libs = set(self.memory_manager.get_libs().keys())
         
         for domain in os.listdir(self.llm_friendly_packages_dir):
             domain_path = os.path.join(self.llm_friendly_packages_dir, domain)
@@ -277,14 +122,11 @@ class LLMFriendlyPackageManager:
         if not self._clone_repository():
             return False
         
-        memory = self._load_memory()
-        
-        if lib_name in memory["libs"]:
+        if self.memory_manager.has_lib(lib_name):
             self.console.print(f"Library {lib_name} is already added")
             return False
         
-        memory["libs"][lib_name] = {}
-        self._save_memory(memory)
+        self.memory_manager.add_lib(lib_name, {})
         self.console.print(f"Added library: {lib_name}")
         return True
     
@@ -298,50 +140,146 @@ class LLMFriendlyPackageManager:
         Returns:
             True if successful, False otherwise
         """
-        memory = self._load_memory()
-        
-        if lib_name not in memory["libs"]:
+        if not self.memory_manager.has_lib(lib_name):
             self.console.print(f"Library {lib_name} is not in the list")
             return False
         
-        del memory["libs"][lib_name]
-        self._save_memory(memory)
+        self.memory_manager.remove_lib(lib_name)
         self.console.print(f"Removed library: {lib_name}")
         return True
     
-    def set_proxy(self, proxy_url: Optional[str] = None) -> str:
+    def has_library(self, lib_name: str) -> bool:
+        """Check if library is added"""
+        return self.memory_manager.has_lib(lib_name)
+    
+    def get_package_path(self, package_name: str) -> Optional[str]:
         """
-        Set or get proxy URL
+        Get the full path of a package by its name
         
         Args:
-            proxy_url: New proxy URL, None to get current proxy
+            package_name: Package name (can be just lib_name or username/lib_name)
             
         Returns:
-            Current proxy URL
+            Full path to the package directory, or None if not found
         """
-        memory = self._load_memory()
+        if not os.path.exists(self.llm_friendly_packages_dir):
+            return None
         
-        if proxy_url is None:
-            current_proxy = memory.get("lib-proxy", "No proxy set")
-            self.console.print(f"Current proxy: {current_proxy}")
-            return current_proxy
+        for domain in os.listdir(self.llm_friendly_packages_dir):
+            domain_path = os.path.join(self.llm_friendly_packages_dir, domain)
+            if not os.path.isdir(domain_path):
+                continue
+                
+            for username in os.listdir(domain_path):
+                username_path = os.path.join(domain_path, username)
+                if not os.path.isdir(username_path):
+                    continue
+                    
+                for lib_name in os.listdir(username_path):
+                    lib_path = os.path.join(username_path, lib_name)
+                    if not os.path.isdir(lib_path):
+                        continue
+                    
+                    # Check if this matches the requested package
+                    if (lib_name == package_name or 
+                        package_name == os.path.join(username, lib_name)):
+                        return lib_path
         
-        memory["lib-proxy"] = proxy_url
-        self._save_memory(memory)
-        self.console.print(f"Set proxy to: {proxy_url}")
-        return proxy_url
+        return None
     
-    def refresh_repository(self) -> bool:
+    # ======== Documentation Management ========
+    
+    def get_docs(self, package_name: Optional[str] = None, return_paths: bool = False) -> DocsList:
         """
-        Refresh the repository by pulling latest changes
+        Get documentation for packages
         
+        Args:
+            package_name: Specific package name to get docs for, None for all packages
+            return_paths: If True, return file paths; if False, return file contents
+            
         Returns:
-            True if successful, False otherwise
+            List of documentation content or file paths
         """
+        docs = []
+        
+        if not os.path.exists(self.llm_friendly_packages_dir):
+            return docs
+        
+        libs = list(self.memory_manager.get_libs().keys())
+        
+        for domain in os.listdir(self.llm_friendly_packages_dir):
+            domain_path = os.path.join(self.llm_friendly_packages_dir, domain)
+            if not os.path.isdir(domain_path):
+                continue
+                
+            for username in os.listdir(domain_path):
+                username_path = os.path.join(domain_path, username)
+                if not os.path.isdir(username_path):
+                    continue
+                    
+                for lib_name in os.listdir(username_path):
+                    lib_path = os.path.join(username_path, lib_name)
+                    
+                    # Check if this is the requested package
+                    if not os.path.isdir(lib_path):
+                        continue
+                        
+                    if package_name is not None:
+                        if not (lib_name == package_name or 
+                               package_name == os.path.join(username, lib_name)):
+                            continue
+                    
+                    # Check if library is added
+                    if lib_name not in libs:
+                        continue
+                    
+                    # Collect markdown files
+                    for root, _, files in os.walk(lib_path):
+                        for file in files:
+                            if file.endswith(".md"):
+                                file_path = os.path.join(root, file)
+                                if return_paths:
+                                    docs.append(file_path)
+                                else:
+                                    try:
+                                        with open(file_path, "r", encoding="utf-8") as f:
+                                            docs.append(f.read())
+                                    except Exception as e:
+                                        self.console.print(f"Error reading {file_path}: {e}")
+        
+        return docs
+    
+    def get_library_docs_paths(self, package_name: str) -> List[str]:
+        """Get documentation file paths for a specific package"""
+        return self.get_docs(package_name, return_paths=True)
+    
+    def get_library_docs_content(self, package_name: str) -> List[str]:
+        """Get documentation content for a specific package"""
+        return self.get_docs(package_name, return_paths=False)
+    
+    # ======== Repository Management ========
+    
+    def _clone_repository(self) -> bool:
+        """Clone the llm_friendly_packages repository"""
+        if os.path.exists(self.llm_friendly_packages_dir):
+            return True
+            
+        self.console.print("Cloning llm_friendly_packages repository...")
+        try:
+            proxy_url = self._get_current_proxy()
+            git.Repo.clone_from(proxy_url, self.llm_friendly_packages_dir)
+            self.console.print("Successfully cloned llm_friendly_packages repository")
+            return True
+        except GitCommandError as e:
+            self.console.print(f"Error cloning repository: {e}")
+            return False
+    
+    def refresh_repository(self) -> bool:
+        """Refresh the repository by pulling latest changes"""
         if not os.path.exists(self.llm_friendly_packages_dir):
             self.console.print(
                 "llm_friendly_packages repository does not exist. "
-                "Please run add_library() first to clone it."
+                "Please call add_library() first to clone it."
             )
             return False
         
@@ -350,8 +288,7 @@ class LLMFriendlyPackageManager:
             origin = repo.remotes.origin
             
             # Update remote URL if proxy is set
-            memory = self._load_memory()
-            proxy_url = memory.get("lib-proxy")
+            proxy_url = self._get_current_proxy()
             current_url = origin.url
             
             if proxy_url and proxy_url != current_url:
@@ -362,21 +299,42 @@ class LLMFriendlyPackageManager:
             self.console.print("Successfully updated llm_friendly_packages repository")
             return True
             
-        except git.exc.GitCommandError as e:
+        except GitCommandError as e:
             self.console.print(f"Error updating repository: {e}")
             return False
     
-    def get_library_docs_paths(self, package_name: str) -> List[str]:
-        """
-        Get documentation file paths for a specific package
+    def set_proxy(self, proxy_url: Optional[str] = None) -> str:
+        """Set or get proxy URL"""
+        if proxy_url is None:
+            current_proxy = self._get_current_proxy()
+            self.console.print(f"Current proxy: {current_proxy}")
+            return current_proxy
         
-        Args:
-            package_name: Package name
-            
-        Returns:
-            List of markdown file paths
-        """
-        return self.get_docs(package_name, return_paths=True)
+        self.memory_manager.set_config("lib-proxy", proxy_url)
+        self.console.print(f"Set proxy to: {proxy_url}")
+        return proxy_url
+    
+    def get_repository_info(self) -> RepositoryInfo:
+        """Get repository information"""
+        exists = os.path.exists(self.llm_friendly_packages_dir)
+        proxy_url = self._get_current_proxy()
+        
+        last_updated = None
+        if exists:
+            try:
+                repo = git.Repo(self.llm_friendly_packages_dir)
+                last_commit = repo.head.commit
+                last_updated = last_commit.committed_datetime.isoformat()
+            except Exception:
+                pass
+        
+        return RepositoryInfo(
+            exists=exists,
+            url=proxy_url,
+            last_updated=last_updated
+        )
+    
+    # ======== Display Management ========
     
     def display_added_libraries(self) -> None:
         """Display added libraries in a table"""
@@ -440,4 +398,19 @@ class LLMFriendlyPackageManager:
         table.add_column("File Path", style="cyan")
         
         for doc in docs:
-            table.add_row(doc) 
+            table.add_row(doc)
+        
+        self.console.print(table)
+
+
+def get_package_manager(project_root: Optional[str] = None) -> LLMFriendlyPackageManager:
+    """
+    Get package manager instance
+    
+    Args:
+        project_root: Project root directory
+        
+    Returns:
+        LLMFriendlyPackageManager instance
+    """
+    return LLMFriendlyPackageManager(project_root)

autocoder/common/llm_friendly_package/models.py

@@ -0,0 +1,40 @@
+"""
+Data models for LLM Friendly Package Manager
+
+This module defines the core data structures used throughout the package manager.
+"""
+
+from dataclasses import dataclass
+from typing import Optional, List, Dict, Any
+
+
+@dataclass
+class LibraryInfo:
+    """Information about a library in the repository"""
+    domain: str
+    username: str
+    lib_name: str
+    full_path: str
+    is_added: bool
+    has_md_files: bool = True
+
+
+@dataclass
+class PackageDoc:
+    """Package documentation information"""
+    file_path: str
+    content: Optional[str] = None
+
+
+@dataclass
+class RepositoryInfo:
+    """Information about the repository state"""
+    exists: bool
+    url: str
+    last_updated: Optional[str] = None
+
+
+# Type aliases for better type hints
+LibraryList = List[LibraryInfo]
+DocsList = List[str]
+ConfigDict = Dict[str, Any]