auto-coder 0.1.382__py3-none-any.whl → 0.1.384__py3-none-any.whl

{auto_coder-0.1.382.dist-info → auto_coder-0.1.384.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.382
+Version: 0.1.384
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Programming Language :: Python :: 3.10

{auto_coder-0.1.382.dist-info → auto_coder-0.1.384.dist-info}/RECORD

@@ -1,7 +1,7 @@
 autocoder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autocoder/auto_coder.py,sha256=7602L3tG0JErNxh8vkLAmGUgv2c-DGPzPCkmWIQt9bs,69757
 autocoder/auto_coder_rag.py,sha256=tRAKfo3jIhcaQKN_3g7DZRKtDJSZXJxMRdT6Zz8W9nw,41173
-autocoder/auto_coder_runner.py,sha256=VktQIEWjVMmraVjD7W73eZmYtdfm9Ma2w_Ib-cWZYhM,112263
+autocoder/auto_coder_runner.py,sha256=NhT1fVdV4NnV2SwpXl7G-tTKgduA0D-0lK_p2R6DWew,115569
 autocoder/auto_coder_server.py,sha256=bLORGEclcVdbBVfM140JCI8WtdrU0jbgqdJIVVupiEU,20578
 autocoder/benchmark.py,sha256=Ypomkdzd1T3GE6dRICY3Hj547dZ6_inqJbBJIp5QMco,4423
 autocoder/chat_auto_coder.py,sha256=vNQwbYkdqeMl07Vx8z6x-kSPkHKn9AT3sSkYMTJiWtc,26655
@@ -11,7 +11,7 @@ autocoder/command_parser.py,sha256=fx1g9E6GaM273lGTcJqaFQ-hoksS_Ik2glBMnVltPCE,1
 autocoder/lang.py,sha256=PFtATuOhHRnfpqHQkXr6p4C893JvpsgwTMif3l-GEi0,14321
 autocoder/models.py,sha256=pD5u6gcMKRwWaLxeVin18g25k-ERyeHOFsRpOgO_Ae0,13788
 autocoder/run_context.py,sha256=IUfSO6_gp2Wt1blFWAmOpN0b0nDrTTk4LmtCYUBIoro,1643
-autocoder/version.py,sha256=WsLgumnTuWnjn9FpRrgmPyKJQyLwiu2BVqZ5GJpgbT0,25
+autocoder/version.py,sha256=GKXrGNop64hmj7p85hlLkViSFSxh9tQvQZ4yEDTAuu4,25
 autocoder/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autocoder/agent/agentic_filter.py,sha256=zlInIRhawKIYTJjCiJBWqPCOV5UtMbh5VnvszfTy2vo,39824
 autocoder/agent/auto_demand_organizer.py,sha256=URAq0gSEiHeV_W4zwhOI_83kHz0Ryfj1gcfh5jwCv_w,6501
@@ -97,6 +97,9 @@ autocoder/common/global_cancel.py,sha256=EYMIzdIJHQjoYP4grxhBxSIT3tCJOy3ESULNd-c
 autocoder/common/image_to_page.py,sha256=yWiTJQ49Lm3j0FngiJhQ9u7qayqE_bOGb8Rk0TmSWx0,14123
 autocoder/common/index_import_export.py,sha256=h758AYY1df6JMTKUXYmMkSgxItfymDt82XT7O-ygEuw,4565
 autocoder/common/interpreter.py,sha256=62-dIakOunYB4yjmX8SHC0Gdy2h8NtxdgbpdqRZJ5vk,2833
+autocoder/common/llm_friendly_package.py,sha256=j44Wqco8-5sA2Yz05ZEidA1HwTbVGnbevbALCoasTtM,14760
+autocoder/common/llm_friendly_package_example.py,sha256=NXUiz6j7gpfzExC-2jmppnZaZaTuu4oGMCDneV7FC_k,4647
+autocoder/common/llm_friendly_package_test.py,sha256=FhbzdNPEceuEBIxNvek2OYDFVlJlYJpkskZ7_PB4YSg,1930
 autocoder/common/mcp_hub.py,sha256=grf51bZbZDXQIqlruIxXZjfat8MoVwK7NvHTHMaxKrg,23614
 autocoder/common/mcp_server.py,sha256=Aj6snmB4XXEcLpcm7SC-KBbNLOlEmiNW6hFtMLltpt8,17624
 autocoder/common/mcp_server_install.py,sha256=vQOWWZsl6MZ2qz3b7Y2zctKOEGO69Ph2Nrof4p_1SOg,11599
@@ -172,7 +175,7 @@ autocoder/common/v2/code_editblock_manager.py,sha256=DMwJw-FAM6VyaBQV3p4xespHpgZ
 autocoder/common/v2/code_manager.py,sha256=C403bS-f6urixwitlKHcml-J03hci-UyNwHJOqBiY6Q,9182
 autocoder/common/v2/code_strict_diff_manager.py,sha256=Bys7tFAq4G03R1zUZuxrszBTvP4QB96jIw2y5BDLyRM,9424
 autocoder/common/v2/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autocoder/common/v2/agent/agentic_edit.py,sha256=aPYUhDyLPALIHzULCHnVSoDc6x2vcrAFXBknxc8k_lg,112210
+autocoder/common/v2/agent/agentic_edit.py,sha256=f9GxvaOvgirxyPCEiGxFi7u8X4ZB3do72PGldxCzpAI,115291
 autocoder/common/v2/agent/agentic_edit_types.py,sha256=nEcZc2MOZ_fQLaJX-YDha_x9Iim22ao4tykYM2iIy4k,4908
 autocoder/common/v2/agent/agentic_tool_display.py,sha256=-a-JTQLc4q03E_rdIILKMI0B6DHN-5gcGlrqq-mBYK4,7239
 autocoder/common/v2/agent/agentic_edit_tools/__init__.py,sha256=RbPZZcZg_VnGssL577GxSyFrYrxQ_LopJ4G_-mY3z_Q,1337
@@ -320,7 +323,7 @@ autocoder/utils/llms.py,sha256=CQRNsX8SJBpeHl_zJ1N-Nj-MYyqkFCi3zETYSurCMkU,4021
 autocoder/utils/log_capture.py,sha256=I-bsJFLWoGUiX-GKoZsH9kWJCKSV7ZlUnRt7jh-fOL0,1548
 autocoder/utils/model_provider_selector.py,sha256=JTYy6GLaqnGoqsumjRNXmQuwy9nDqiTSZlGQ9zkfdK0,8102
 autocoder/utils/multi_turn.py,sha256=unK9OpqVRbK6uIcTKXgggX2wNmyj7s5eyEAQ2xUwHoM,88
-autocoder/utils/operate_config_api.py,sha256=K1lQxXNHiAYTgRDS2EGpWmjdJTrQaeP16RUWS0DIorw,5841
+autocoder/utils/operate_config_api.py,sha256=j9Ika5bbAGSQbFziREwISmp8BQ54m_eigEa5jwdG64Q,4530
 autocoder/utils/print_table.py,sha256=ZMRhCA9DD0FUfKyJBWd5bDdj1RrtPtgOMWSJwtvZcLs,403
 autocoder/utils/project_structure.py,sha256=KnRWtGsJSmZrEV5aOOjv120vvBkZ1UZtDTnWkzpMmKI,11426
 autocoder/utils/queue_communicate.py,sha256=buyEzdvab1QA4i2QKbq35rG5v_9x9PWVLWWMTznWcYM,6832
@@ -333,9 +336,9 @@ autocoder/utils/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autocoder/utils/auto_coder_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autocoder/utils/auto_coder_utils/chat_stream_out.py,sha256=t902pKxQ5xM7zgIHiAOsTPLwxhE6VuvXAqPy751S7fg,14096
 autocoder/utils/chat_auto_coder_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-auto_coder-0.1.382.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-auto_coder-0.1.382.dist-info/METADATA,sha256=PVXxhMLwdBO7U8UTU5jHi6gAsMUOoETYAsWTeWNvldI,2796
-auto_coder-0.1.382.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-auto_coder-0.1.382.dist-info/entry_points.txt,sha256=0nzHtHH4pNcM7xq4EBA2toS28Qelrvcbrr59GqD_0Ak,350
-auto_coder-0.1.382.dist-info/top_level.txt,sha256=Jqc0_uJSw2GwoFQAa9iJxYns-2mWla-9ok_Y3Gcznjk,10
-auto_coder-0.1.382.dist-info/RECORD,,
+auto_coder-0.1.384.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+auto_coder-0.1.384.dist-info/METADATA,sha256=rPHocW41diQxO73kihXrTOfC8r9HBwK07EUF5X_F960,2796
+auto_coder-0.1.384.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+auto_coder-0.1.384.dist-info/entry_points.txt,sha256=0nzHtHH4pNcM7xq4EBA2toS28Qelrvcbrr59GqD_0Ak,350
+auto_coder-0.1.384.dist-info/top_level.txt,sha256=Jqc0_uJSw2GwoFQAa9iJxYns-2mWla-9ok_Y3Gcznjk,10
+auto_coder-0.1.384.dist-info/RECORD,,

autocoder/auto_coder_runner.py

@@ -657,6 +657,16 @@ def save_memory():
     load_memory()
 
 
+def save_memory_with_new_memory(new_memory):
+    memory_path = os.path.join(base_persist_dir, "memory.json")
+    lock_path = memory_path + ".lock"
+    
+    with FileLock(lock_path, timeout=30):
+        with open(memory_path, "w", encoding="utf-8") as f:
+            json.dump(new_memory, f, indent=2, ensure_ascii=False)
+    load_memory()        
+
+
 def load_memory():    
     global memory
     memory_path = os.path.join(base_persist_dir, "memory.json")
@@ -2653,7 +2663,7 @@ def lib_command(args: List[str]):
 
     if not args:
         console.print(
-            "Please specify a subcommand: /add, /remove, /list, /set-proxy, /refresh, or /get"
+            "Please specify a subcommand: /add, /remove, /list, /list_all, /set-proxy, /refresh, or /get"
         )
         return
 
@@ -2710,6 +2720,66 @@ def lib_command(args: List[str]):
             console.print(table)
         else:
             console.print("No libraries added yet")
+            
+    elif subcommand == "/list_all":
+        if not os.path.exists(llm_friendly_packages_dir):
+            console.print("llm_friendly_packages repository does not exist. Please run /lib /add <library_name> command first to clone it.")
+            return
+            
+        available_libs = []
+        
+        # 遍历所有domain目录
+        for domain in os.listdir(llm_friendly_packages_dir):
+            domain_path = os.path.join(llm_friendly_packages_dir, domain)
+            if os.path.isdir(domain_path):
+                # 遍历所有username目录
+                for username in os.listdir(domain_path):
+                    username_path = os.path.join(domain_path, username)
+                    if os.path.isdir(username_path):
+                        # 遍历所有lib_name目录
+                        for lib_name in os.listdir(username_path):
+                            lib_path = os.path.join(username_path, lib_name)
+                            if os.path.isdir(lib_path):
+                                # 检查是否有Markdown文件
+                                has_md_files = False
+                                for root, _, files in os.walk(lib_path):
+                                    if any(file.endswith('.md') for file in files):
+                                        has_md_files = True
+                                        break
+                                
+                                if has_md_files:
+                                    available_libs.append({
+                                        "domain": domain,
+                                        "username": username,
+                                        "lib_name": lib_name,
+                                        "full_path": f"{username}/{lib_name}",
+                                        "is_added": lib_name in memory["libs"]
+                                    })
+        
+        if available_libs:
+            table = Table(title="Available Libraries")
+            table.add_column("Domain", style="blue")
+            table.add_column("Username", style="green")
+            table.add_column("Library Name", style="cyan")
+            table.add_column("Full Path", style="magenta")
+            table.add_column("Status", style="yellow")
+            
+            # 按domain和username分组排序
+            available_libs.sort(key=lambda x: (x["domain"], x["username"], x["lib_name"]))
+            
+            for lib in available_libs:
+                status = "[green]Added[/green]" if lib["is_added"] else "[white]Not Added[/white]"
+                table.add_row(
+                    lib["domain"],
+                    lib["username"],
+                    lib["lib_name"],
+                    lib["full_path"],
+                    status
+                )
+            
+            console.print(table)
+        else:
+            console.print("No available libraries found in the repository.")
 
     elif subcommand == "/set-proxy":
         if len(args) == 1:

autocoder/common/llm_friendly_package.py

@@ -0,0 +1,410 @@
+"""
+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.
+"""
+
+import os
+import json
+from typing import List, Dict, Any, Optional, Tuple
+from dataclasses import dataclass
+from rich.console import Console
+from rich.table import Table
+import git
+from filelock import FileLock
+
+
+@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
+
+
+class LLMFriendlyPackageManager:
+    """Manager for LLM friendly packages"""
+    
+    def __init__(self, project_root: str = None, base_persist_dir: 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.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")
+    
+    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 _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)
+    
+    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
+    
+    def list_added_libraries(self) -> List[str]:
+        """List all added libraries"""
+        memory = self._load_memory()
+        return list(memory.get("libs", {}).keys())
+    
+    def list_all_available_libraries(self) -> List[LibraryInfo]:
+        """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())
+        
+        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 has markdown files
+                    has_md_files = False
+                    for root, _, files in os.walk(lib_path):
+                        if any(file.endswith('.md') for file in files):
+                            has_md_files = True
+                            break
+                    
+                    if has_md_files:
+                        available_libs.append(LibraryInfo(
+                            domain=domain,
+                            username=username,
+                            lib_name=lib_name,
+                            full_path=f"{username}/{lib_name}",
+                            is_added=lib_name in added_libs,
+                            has_md_files=has_md_files
+                        ))
+        
+        # Sort by domain, username, lib_name
+        available_libs.sort(key=lambda x: (x.domain, x.username, x.lib_name))
+        return available_libs
+    
+    def add_library(self, lib_name: str) -> bool:
+        """
+        Add a library to the list
+        
+        Args:
+            lib_name: Library name to add
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        # Clone repository if needed
+        if not self._clone_repository():
+            return False
+        
+        memory = self._load_memory()
+        
+        if lib_name in memory["libs"]:
+            self.console.print(f"Library {lib_name} is already added")
+            return False
+        
+        memory["libs"][lib_name] = {}
+        self._save_memory(memory)
+        self.console.print(f"Added library: {lib_name}")
+        return True
+    
+    def remove_library(self, lib_name: str) -> bool:
+        """
+        Remove a library from the list
+        
+        Args:
+            lib_name: Library name to remove
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        memory = self._load_memory()
+        
+        if lib_name not in memory["libs"]:
+            self.console.print(f"Library {lib_name} is not in the list")
+            return False
+        
+        del memory["libs"][lib_name]
+        self._save_memory(memory)
+        self.console.print(f"Removed library: {lib_name}")
+        return True
+    
+    def set_proxy(self, proxy_url: Optional[str] = None) -> str:
+        """
+        Set or get proxy URL
+        
+        Args:
+            proxy_url: New proxy URL, None to get current proxy
+            
+        Returns:
+            Current proxy URL
+        """
+        memory = self._load_memory()
+        
+        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
+        
+        memory["lib-proxy"] = proxy_url
+        self._save_memory(memory)
+        self.console.print(f"Set proxy to: {proxy_url}")
+        return proxy_url
+    
+    def refresh_repository(self) -> bool:
+        """
+        Refresh the repository by pulling latest changes
+        
+        Returns:
+            True if successful, False otherwise
+        """
+        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."
+            )
+            return False
+        
+        try:
+            repo = git.Repo(self.llm_friendly_packages_dir)
+            origin = repo.remotes.origin
+            
+            # Update remote URL if proxy is set
+            memory = self._load_memory()
+            proxy_url = memory.get("lib-proxy")
+            current_url = origin.url
+            
+            if proxy_url and proxy_url != current_url:
+                origin.set_url(proxy_url)
+                self.console.print(f"Updated remote URL to: {proxy_url}")
+            
+            origin.pull()
+            self.console.print("Successfully updated llm_friendly_packages repository")
+            return True
+            
+        except git.exc.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
+        
+        Args:
+            package_name: Package name
+            
+        Returns:
+            List of markdown file paths
+        """
+        return self.get_docs(package_name, return_paths=True)
+    
+    def display_added_libraries(self) -> None:
+        """Display added libraries in a table"""
+        libs = self.list_added_libraries()
+        
+        if not libs:
+            self.console.print("No libraries added yet")
+            return
+        
+        table = Table(title="Added Libraries")
+        table.add_column("Library Name", style="cyan")
+        
+        for lib_name in libs:
+            table.add_row(lib_name)
+        
+        self.console.print(table)
+    
+    def display_all_libraries(self) -> None:
+        """Display all available libraries in a table"""
+        if not os.path.exists(self.llm_friendly_packages_dir):
+            self.console.print(
+                "llm_friendly_packages repository does not exist. "
+                "Please call add_library() first to clone it."
+            )
+            return
+        
+        available_libs = self.list_all_available_libraries()
+        
+        if not available_libs:
+            self.console.print("No available libraries found in the repository.")
+            return
+        
+        table = Table(title="Available Libraries")
+        table.add_column("Domain", style="blue")
+        table.add_column("Username", style="green")
+        table.add_column("Library Name", style="cyan")
+        table.add_column("Full Path", style="magenta")
+        table.add_column("Status", style="yellow")
+        
+        for lib in available_libs:
+            status = "[green]Added[/green]" if lib.is_added else "[white]Not Added[/white]"
+            table.add_row(
+                lib.domain,
+                lib.username,
+                lib.lib_name,
+                lib.full_path,
+                status
+            )
+        
+        self.console.print(table)
+    
+    def display_library_docs(self, package_name: str) -> None:
+        """Display documentation paths for a package in a table"""
+        docs = self.get_library_docs_paths(package_name)
+        
+        if not docs:
+            self.console.print(f"No markdown files found for package: {package_name}")
+            return
+        
+        table = Table(title=f"Markdown Files for {package_name}")
+        table.add_column("File Path", style="cyan")
+        
+        for doc in docs:
+            table.add_row(doc)
+        
+        self.console.print(table) 

autocoder/common/llm_friendly_package_example.py

@@ -0,0 +1,138 @@
+"""
+LLMFriendlyPackageManager Usage Examples
+
+This file demonstrates various ways to use the LLMFriendlyPackageManager class
+for managing LLM friendly packages.
+"""
+
+from autocoder.common.llm_friendly_package import LLMFriendlyPackageManager
+
+def example_basic_usage():
+    """Basic usage example"""
+    print("=== Basic Usage Example ===")
+    
+    # Initialize the manager
+    manager = LLMFriendlyPackageManager()
+    
+    # List current added libraries
+    added_libs = manager.list_added_libraries()
+    print(f"Currently added libraries: {added_libs}")
+    
+    # Display added libraries in a nice table
+    manager.display_added_libraries()
+
+def example_library_management():
+    """Library management example"""
+    print("\n=== Library Management Example ===")
+    
+    manager = LLMFriendlyPackageManager()
+    
+    # Add a library (this will clone the repository if needed)
+    print("Adding a library...")
+    success = manager.add_library("example-lib")
+    if success:
+        print("Library added successfully!")
+    
+    # List all available libraries
+    print("\nAll available libraries:")
+    manager.display_all_libraries()
+    
+    # Remove a library
+    print("\nRemoving the library...")
+    removed = manager.remove_library("example-lib")
+    if removed:
+        print("Library removed successfully!")
+
+def example_documentation_access():
+    """Documentation access example"""
+    print("\n=== Documentation Access Example ===")
+    
+    manager = LLMFriendlyPackageManager()
+    
+    # Get documentation content for all packages
+    docs_content = manager.get_docs()
+    print(f"Total documentation content items: {len(docs_content)}")
+    
+    # Get documentation file paths for all packages
+    docs_paths = manager.get_docs(return_paths=True)
+    print(f"Total documentation files: {len(docs_paths)}")
+    
+    # Get documentation for a specific package
+    specific_docs = manager.get_docs(package_name="some-package", return_paths=True)
+    print(f"Documentation files for 'some-package': {len(specific_docs)}")
+    
+    # Display documentation paths for a specific package
+    manager.display_library_docs("some-package")
+
+def example_repository_management():
+    """Repository management example"""
+    print("\n=== Repository Management Example ===")
+    
+    manager = LLMFriendlyPackageManager()
+    
+    # Get current proxy setting
+    current_proxy = manager.set_proxy()
+    print(f"Current proxy: {current_proxy}")
+    
+    # Set a new proxy (optional)
+    # manager.set_proxy("https://gitee.com/your-mirror/llm_friendly_packages")
+    
+    # Refresh the repository to get latest changes
+    print("Refreshing repository...")
+    success = manager.refresh_repository()
+    if success:
+        print("Repository refreshed successfully!")
+
+def example_data_access():
+    """Data access example"""
+    print("\n=== Data Access Example ===")
+    
+    manager = LLMFriendlyPackageManager()
+    
+    # Get all available libraries as structured data
+    available_libs = manager.list_all_available_libraries()
+    print(f"Total available libraries: {len(available_libs)}")
+    
+    # Process the library information
+    for lib in available_libs[:3]:  # Show first 3
+        print(f"Domain: {lib.domain}, "
+              f"Username: {lib.username}, "
+              f"Library: {lib.lib_name}, "
+              f"Added: {lib.is_added}")
+
+def example_custom_configuration():
+    """Custom configuration example"""
+    print("\n=== Custom Configuration Example ===")
+    
+    # Initialize with custom directories (using existing project directory)
+    import tempfile
+    import os
+    
+    # Create a temporary directory for demonstration
+    with tempfile.TemporaryDirectory() as temp_dir:
+        custom_project_root = temp_dir
+        custom_persist_dir = os.path.join(temp_dir, "custom_persist")
+        
+        manager = LLMFriendlyPackageManager(
+            project_root=custom_project_root,
+            base_persist_dir=custom_persist_dir
+        )
+        
+        print("Manager initialized with custom configuration")
+        print(f"Project root: {custom_project_root}")
+        print(f"Persistence directory: {custom_persist_dir}")
+        
+        # Use the manager with custom configuration
+        added_libs = manager.list_added_libraries()
+        print(f"Added libraries with custom config: {added_libs}")
+
+if __name__ == "__main__":
+    # Run all examples
+    example_basic_usage()
+    example_library_management()
+    example_documentation_access()
+    example_repository_management()
+    example_data_access()
+    example_custom_configuration()
+    
+    print("\n=== All examples completed ===") 

autocoder/common/llm_friendly_package_test.py

@@ -0,0 +1,63 @@
+"""
+Test script for LLMFriendlyPackageManager
+
+This script demonstrates the usage of the new LLMFriendlyPackageManager class.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Add the project root to the Python path
+project_root = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from autocoder.common.llm_friendly_package import LLMFriendlyPackageManager
+
+def test_llm_friendly_package_manager():
+    """Test the LLMFriendlyPackageManager functionality"""
+    
+    # Initialize the manager
+    manager = LLMFriendlyPackageManager()
+    
+    print("=== Testing LLMFriendlyPackageManager ===\n")
+    
+    # Test 1: Display added libraries (should be empty initially)
+    print("1. Testing display_added_libraries():")
+    manager.display_added_libraries()
+    print()
+    
+    # Test 2: List added libraries programmatically
+    print("2. Testing list_added_libraries():")
+    added_libs = manager.list_added_libraries()
+    print(f"Added libraries: {added_libs}")
+    print()
+    
+    # Test 3: Show current proxy
+    print("3. Testing set_proxy() to get current proxy:")
+    current_proxy = manager.set_proxy()
+    print(f"Current proxy: {current_proxy}")
+    print()
+    
+    # Test 4: Try to get docs (should be empty if no libraries added)
+    print("4. Testing get_docs():")
+    docs = manager.get_docs(return_paths=True)
+    print(f"Number of documentation files found: {len(docs)}")
+    if docs:
+        print("First few docs:")
+        for i, doc in enumerate(docs[:3]):
+            print(f"  - {doc}")
+    print()
+    
+    # Test 5: Display all available libraries (may require repository)
+    print("5. Testing display_all_libraries():")
+    try:
+        manager.display_all_libraries()
+    except Exception as e:
+        print(f"Could not display all libraries: {e}")
+    print()
+    
+    print("=== Test completed ===")
+
+if __name__ == "__main__":
+    test_llm_friendly_package_manager() 

autocoder/common/v2/agent/agentic_edit.py

@@ -58,6 +58,7 @@ from autocoder.common.v2.agent.agentic_edit_tools import (  # Import specific re
     AttemptCompletionToolResolver, PlanModeRespondToolResolver, UseMcpToolResolver,
     ListPackageInfoToolResolver
 )
+from autocoder.common.llm_friendly_package import LLMFriendlyPackageManager
 from autocoder.common.rulefiles.autocoderrules_utils import get_rules,auto_select_rules,get_required_and_index_rules
 from autocoder.common.v2.agent.agentic_edit_types import (AgenticEditRequest, ToolResult,
                                                           MemoryConfig, CommandConfig, BaseTool,
@@ -127,7 +128,8 @@ class AgenticEdit:
         self.memory_config = memory_config
         self.command_config = command_config  # Note: command_config might be unused now
         self.project_type_analyzer = ProjectTypeAnalyzer(
-            args=args, llm=self.llm)        
+            args=args, llm=self.llm)
+        self.base_persist_dir = os.path.join(args.source_dir, ".auto-coder", "plugins", "chat-auto-coder")        
 
         # self.shadow_manager = ShadowManager(
         #     args.source_dir, args.event_file, args.ignore_clean_shadows)
@@ -163,6 +165,33 @@ class AgenticEdit:
         # 格式: { file_path: FileChangeEntry(...) }
         self.file_changes: Dict[str, FileChangeEntry] = {}
 
+    @byzerllm.prompt()
+    def generate_library_docs_prompt(self, libraries: List[str], docs_content: str) -> Dict[str, Any]:
+        """
+        ====
+
+        THIRD-PARTY LIBRARY DOCUMENTATION
+
+        The following documentation is for third-party libraries that are available in this project. Use this information to understand the capabilities and APIs of these libraries when they are relevant to the user's task.
+
+        Libraries included: {{ libraries_list }}
+
+        <library_documentation>
+        {{ combined_docs }}
+        </library_documentation>
+
+        You should reference this documentation when:
+        1. The user asks about functionality that might be provided by these libraries
+        2. You need to implement features that could leverage these library capabilities  
+        3. You want to suggest using library functions instead of implementing from scratch
+        4. You need to understand the API or usage patterns of these libraries
+        ====
+        """
+        return {
+            "libraries_list": ", ".join(libraries),
+            "combined_docs": docs_content
+        }
+
     def record_file_change(self, file_path: str, change_type: str, diff: Optional[str] = None, content: Optional[str] = None):
         """
         记录单个文件的变更信息。
@@ -801,6 +830,43 @@ class AgenticEdit:
         conversations = [
             {"role": "system", "content": system_prompt},
         ] 
+        
+        # Add third-party library documentation information
+        try:
+            package_manager = LLMFriendlyPackageManager(
+                project_root=self.args.source_dir,
+                base_persist_dir=self.base_persist_dir
+            )
+            
+            # Get list of added libraries
+            added_libraries = package_manager.list_added_libraries()
+            
+            if added_libraries:
+                # Get documentation content for all added libraries
+                docs_content = package_manager.get_docs(return_paths=False)
+                
+                if docs_content:
+                    # Combine all documentation content
+                    combined_docs = "\n\n".join(docs_content)
+                    
+                    # Generate library documentation prompt using decorator
+                    library_docs_prompt = self.generate_library_docs_prompt.prompt(
+                        libraries=added_libraries,
+                        docs_content=combined_docs
+                    )
+                    
+                    conversations.append({
+                        "role": "user", 
+                        "content": library_docs_prompt
+                    })
+                    
+                    conversations.append({
+                        "role": "assistant",
+                        "content": "我已经阅读并理解了项目中可用的第三方库文档信息。在处理您的请求时，我会适当地参考这些库的功能和API，帮助您更好地利用这些库的能力。"
+                    })
+                    
+        except Exception as e:
+            logger.warning(f"Failed to load library documentation: {str(e)}")
                                 
         conversations.append({
             "role": "user", "content": request.user_input
@@ -824,7 +890,8 @@ class AgenticEdit:
 
         while True:
             iteration_count += 1            
-            logger.info(f"Starting LLM interaction cycle #{iteration_count}")
+            logger.info(f"Starting LLM interaction cycle #{iteration_count}, reset tool_executed to False")
+            tool_executed = False
             global_cancel.check_and_raise(token=self.args.event_file)
             last_message = conversations[-1]
             if last_message["role"] == "assistant":

autocoder/utils/operate_config_api.py

@@ -41,44 +41,20 @@ def convert_yaml_config_to_str(yaml_config):
 def get_llm_friendly_package_docs(memory,
                                   package_name: Optional[str] = None, return_paths: bool = False
                                   ) -> List[str]:
-    lib_dir = os.path.join(".auto-coder", "libs")
-    llm_friendly_packages_dir = os.path.join(lib_dir, "llm_friendly_packages")
-    docs = []
-
-    if not os.path.exists(llm_friendly_packages_dir):
-        print("llm_friendly_packages directory not found.")
-        return docs
-
-    libs = list(memory.get("libs", {}).keys())
-
-    for domain in os.listdir(llm_friendly_packages_dir):
-        domain_path = os.path.join(llm_friendly_packages_dir, domain)
-        if os.path.isdir(domain_path):
-            for username in os.listdir(domain_path):
-                username_path = os.path.join(domain_path, username)
-                if os.path.isdir(username_path):
-                    for lib_name in os.listdir(username_path):
-                        lib_path = os.path.join(username_path, lib_name)
-                        if (
-                            os.path.isdir(lib_path)
-                            and (
-                                package_name is None
-                                or lib_name == package_name
-                                or package_name == os.path.join(username, lib_name)
-                            )
-                            and lib_name in libs
-                        ):
-                            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:
-                                            with open(file_path, "r",encoding="utf-8") as f:
-                                                docs.append(f.read())
-
-    return docs
+    """
+    Legacy function for backward compatibility.
+    Use LLMFriendlyPackageManager class for new code.
+    """
+    from autocoder.common.llm_friendly_package import LLMFriendlyPackageManager
+    
+    project_root = os.getcwd()
+    base_persist_dir = os.path.join(project_root, ".auto-coder", "plugins", "chat-auto-coder")
+    
+    manager = LLMFriendlyPackageManager(
+        project_root=project_root,
+        base_persist_dir=base_persist_dir
+    )
+    return manager.get_docs(package_name, return_paths)
 
 
 def convert_config_value(key, value):

autocoder/version.py

@@ -1,2 +1,2 @@
 
-__version__ = "0.1.382"
+__version__ = "0.1.384"