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

autocoder/common/directory_cache/cache.py

@@ -1,192 +0,0 @@
-from __future__ import annotations
-import os, fnmatch, asyncio
-from watchfiles import Change
-from autocoder.common.ignorefiles.ignore_file_utils import should_ignore
-from autocoder.common.file_monitor.monitor import get_file_monitor
-import logging
-import functools
-
-logger = logging.getLogger(__name__)
-
-class DirectoryCache:
-    _instance: "DirectoryCache|None" = None
-
-    def __init__(self, root: str):
-        self.root = os.path.abspath(root)
-        self.files_set: set[str] = set()
-        self.lock = asyncio.Lock()
-        self._main_loop = asyncio.get_event_loop()  # 保存主事件循环引用
-        logger.info(f"Initializing DirectoryCache for root: {self.root}")
-
-    # ---------- 单例获取 ----------
-    @classmethod
-    def get_instance(cls, root: str | None = None) -> "DirectoryCache":
-        if cls._instance is None:
-            if root is None:
-                raise ValueError("root is required when initializing DirectoryCache for the first time")
-            logger.info("Creating new DirectoryCache instance.")
-            cls._instance = cls(root)
-            cls._instance._build()      # 同步首扫
-            cls._instance._register_monitor()
-        elif root is not None and os.path.abspath(root) != cls._instance.root:
-             # 如果请求的 root 与已存在的实例 root 不同，可以选择抛出错误或重新初始化
-             logger.warning(f"Requested root {os.path.abspath(root)} differs from existing instance root {cls._instance.root}. Re-initializing cache.")
-             cls._instance = cls(root)
-             cls._instance._build()
-             cls._instance._register_monitor()
-
-        return cls._instance
-
-    # ---------- 构建 ----------
-    def _build(self) -> None:
-        logger.info(f"Building initial file cache for {self.root}...")
-        count = 0
-        for r, ds, fs in os.walk(self.root, followlinks=True):
-            # 过滤掉需要忽略的目录
-            ds[:] = [d for d in ds if not should_ignore(os.path.join(r, d))]
-            for f in fs:
-                fp = os.path.join(r, f)
-                abs_fp = os.path.abspath(fp)
-                if not should_ignore(abs_fp):
-                    self.files_set.add(abs_fp)
-                    count += 1
-        logger.info(f"Initial cache build complete. Found {count} files.")
-
-
-    # ---------- 监控回调 ----------
-    def _register_monitor(self) -> None:
-        try:
-            logger.info(f"Registering file monitor for {self.root}")
-            mon = get_file_monitor(self.root)
-            # 使用 functools.partial 包装异步回调
-            async_callback_wrapper = functools.partial(self._on_change_wrapper)
-            mon.register("**/*", async_callback_wrapper) # 监听所有文件变化
-            if not mon.is_running():
-                logger.info("Starting file monitor...")
-                mon.start()
-            logger.info("File monitor registered and running.")
-        except Exception as e:
-            logger.error(f"Failed to register or start file monitor: {e}", exc_info=True)
-
-    # Wrapper to run the async callback in the event loop
-    def _on_change_wrapper(self, change: Change, path: str):
-        try:
-            # 使用run_coroutine_threadsafe在主事件循环中运行协程
-            # 注意：主事件循环必须在其他地方运行，如主线程中
-            asyncio.run_coroutine_threadsafe(self._on_change(change, path), self._main_loop)
-        except Exception as e:
-            logger.error(f"Error executing _on_change_wrapper: {e}", exc_info=True)
-            # 如果run_coroutine_threadsafe失败，可以考虑一个同步的备用处理方法
-            try:
-                # 同步备份处理
-                ap = os.path.abspath(path)
-                if should_ignore(ap):
-                    return
-                
-                if change is Change.added:
-                    self.files_set.add(ap)
-                elif change is Change.deleted:
-                    self.files_set.discard(ap)
-                # Change.modified不需要更新集合
-            except Exception as backup_error:
-                logger.error(f"Backup handler also failed: {backup_error}", exc_info=True)
-
-
-    async def _on_change(self, change: Change, path: str) -> None:
-        ap = os.path.abspath(path)
-        # Check ignore status again, as gitignore might change
-        if should_ignore(ap):
-            # If a previously tracked file becomes ignored, remove it
-            async with self.lock:
-                if ap in self.files_set:
-                    logger.debug(f"File became ignored, removing from cache: {ap}")
-                    self.files_set.discard(ap)
-            return
-
-        async with self.lock:
-            if change is Change.added:
-                logger.debug(f"File added, adding to cache: {ap}")
-                self.files_set.add(ap)
-            elif change is Change.deleted:
-                logger.debug(f"File deleted, removing from cache: {ap}")
-                self.files_set.discard(ap)
-            elif change is Change.modified:
-                 # Modification doesn't change existence, but we might want to log or handle metadata updates if needed
-                 logger.debug(f"File modified: {ap} (ignored in cache set)")
-                 pass # No change needed for the set itself
-
-    # ---------- 查询 ----------
-    async def query(self, patterns: list[str]) -> list[str]:
-        logger.debug(f"Querying cache with patterns: {patterns}")
-        async with self.lock:
-            # Make a copy to avoid issues if the set is modified during iteration (though lock prevents this here)
-            current_files = list(self.files_set)
-
-        if not patterns or patterns == [""] or patterns == ["*"]:
-             logger.debug(f"Returning all {len(current_files)} cached files.")
-             return current_files
-
-        out: set[str] = set()
-
-        for p in patterns:
-            pattern_abs = os.path.abspath(os.path.join(self.root, p)) if not os.path.isabs(p) else p
-            is_glob = "*" in p or "?" in p or "[" in p # More robust glob check
-
-            try:
-                if is_glob:
-                    # fnmatch expects relative paths for matching within a root usually,
-                    # but here we match against absolute paths in files_set.
-                    # We need a pattern that works with absolute paths.
-                    # If pattern 'p' is like '*.py', we need to match '/path/to/root/**/*.py'
-                    # Let's adjust the pattern logic or filtering logic.
-
-                    # Option 1: Match relative paths within the root
-                    # Convert absolute paths in files_set to relative for matching
-                    # relative_files = [os.path.relpath(f, self.root) for f in current_files]
-                    # matched_relative = fnmatch.filter(relative_files, p)
-                    # out.update(os.path.join(self.root, rel_f) for rel_f in matched_relative)
-
-                    # Option 2: Match absolute paths directly (might need careful pattern construction)
-                    # If p is relative, make it absolute based on root for matching
-                    # Example: p = "src/*.py" -> effective_pattern = "/path/to/root/src/*.py"
-                    # This requires fnmatch to handle absolute paths correctly or custom logic.
-
-                    # Option 3: Simplified wildcard matching on absolute paths
-                    # Treat '*' as a general wildcard anywhere in the path.
-                    # fnmatch.filter might work if the pattern is constructed like `*pattern*`
-                    # Let's stick to the user's original logic first, assuming it worked for their case
-                    # The original `*{p}*` suggests substring matching with wildcards? Let's refine.
-
-                    # Refined Glob Matching:
-                    # If p contains wildcards, assume it's a glob pattern relative to root.
-                    # Convert files_set paths to relative for matching.
-                    for f_abs in current_files:
-                        f_rel = os.path.relpath(f_abs, self.root)
-                        if fnmatch.fnmatch(f_rel, p) or fnmatch.fnmatch(os.path.basename(f_abs), p):
-                             out.add(f_abs)
-
-                else:
-                    # Exact or substring matching for non-glob patterns
-                    # Match against filename or full path segment
-                    p_lower = p.lower()
-                    for f_abs in current_files:
-                        if p_lower in os.path.basename(f_abs).lower() or p_lower in f_abs.lower():
-                             out.add(f_abs)
-
-            except Exception as e:
-                logger.error(f"Error during pattern matching for '{p}': {e}", exc_info=True)
-
-
-        result = sorted(list(out)) # Sort for consistent output
-        logger.debug(f"Query returned {len(result)} files.")
-        return result
-
-# Helper function (optional, could be integrated into get_instance)
-def initialize_cache(root_path: str):
-    """Initializes the DirectoryCache singleton."""
-    try:
-        DirectoryCache.get_instance(root_path)
-        logger.info("DirectoryCache initialized successfully.")
-    except Exception as e:
-        logger.error(f"Failed to initialize DirectoryCache: {e}", exc_info=True)
-

autocoder/common/directory_cache/test_cache.py

@@ -1,190 +0,0 @@
-import pytest
-import os
-import tempfile
-import shutil
-import asyncio
-from unittest.mock import patch, MagicMock
-
-# 导入被测模块
-from autocoder.common.directory_cache.cache import DirectoryCache
-
-# 测试环境辅助函数
-def create_test_environment(base_dir, structure):
-    """创建测试所需的文件/目录结构"""
-    for path, content in structure.items():
-        full_path = os.path.join(base_dir, path)
-        os.makedirs(os.path.dirname(full_path), exist_ok=True)
-        with open(full_path, 'w', encoding='utf-8') as f:
-            f.write(content)
-
-# Pytest Fixture: 临时目录
-@pytest.fixture(scope="function")
-def temp_test_dir():
-    """提供一个临时的、测试后自动清理的目录"""
-    temp_dir = tempfile.mkdtemp()
-    print(f"创建测试临时目录: {temp_dir}")
-    yield temp_dir
-    print(f"清理测试临时目录: {temp_dir}")
-    shutil.rmtree(temp_dir)
-
-# Pytest Fixture: 重置单例
-@pytest.fixture(autouse=True)
-def reset_singleton():
-    """每次测试前重置DirectoryCache单例"""
-    DirectoryCache._instance = None
-    yield
-    DirectoryCache._instance = None
-
-# Pytest Fixture: 文件监视器模拟
-@pytest.fixture
-def mock_file_monitor():
-    """模拟文件监视器"""
-    mock_monitor = MagicMock()
-    mock_monitor.register = MagicMock()
-    mock_monitor.is_running = MagicMock(return_value=False)
-    mock_monitor.start = MagicMock()
-    
-    with patch('autocoder.common.directory_cache.cache.get_file_monitor', return_value=mock_monitor):
-        yield mock_monitor
-
-# --- 测试用例 ---
-
-@pytest.mark.asyncio
-async def test_initialization(temp_test_dir, mock_file_monitor):
-    """测试DirectoryCache的初始化和单例模式"""
-    # 创建测试文件结构
-    create_test_environment(temp_test_dir, {
-        "file1.txt": "测试内容1",
-        "subdir/file2.txt": "测试内容2",
-        ".gitignore": "*.ignored"
-    })
-    create_test_environment(temp_test_dir, {
-        "file3.ignored": "这个文件应该被忽略"
-    })
-    
-    # 获取实例
-    cache = DirectoryCache.get_instance(temp_test_dir)
-    
-    # 验证单例模式
-    assert DirectoryCache.get_instance() is cache
-    assert cache.root == os.path.abspath(temp_test_dir)
-    
-    # 验证文件缓存构建
-    assert len(cache.files_set) == 3  # file1.txt, subdir/file2.txt, .gitignore
-    assert os.path.join(temp_test_dir, "file1.txt") in [os.path.normpath(f) for f in cache.files_set]
-    assert os.path.join(temp_test_dir, "subdir/file2.txt") in [os.path.normpath(f) for f in cache.files_set]
-    
-    # 验证监视器注册
-    mock_file_monitor.register.assert_called_once()
-    mock_file_monitor.start.assert_called_once()
-
-@pytest.mark.asyncio
-async def test_query_all_files(temp_test_dir, mock_file_monitor):
-    """测试查询所有文件"""
-    # 创建测试文件结构
-    create_test_environment(temp_test_dir, {
-        "file1.py": "def test(): pass",
-        "file2.txt": "text content",
-        "subdir/file3.py": "class Test: pass"
-    })
-    
-    # 获取实例并查询所有文件
-    cache = DirectoryCache.get_instance(temp_test_dir)
-    result = await cache.query(["*"])
-    
-    # 验证结果
-    assert len(result) == 3
-    assert sorted([os.path.basename(f) for f in result]) == ["file1.py", "file2.txt", "file3.py"]
-
-@pytest.mark.asyncio
-async def test_query_with_pattern(temp_test_dir, mock_file_monitor):
-    """测试使用模式查询文件"""
-    # 创建测试文件结构
-    create_test_environment(temp_test_dir, {
-        "file1.py": "def test(): pass",
-        "file2.txt": "text content",
-        "subdir/file3.py": "class Test: pass",
-        "another.doc": "document"
-    })
-    
-    # 获取实例
-    cache = DirectoryCache.get_instance(temp_test_dir)
-    
-    # 测试不同的查询模式
-    py_files = await cache.query(["*.py"])
-    assert len(py_files) == 2
-    assert all(f.endswith('.py') for f in py_files)
-    
-    txt_files = await cache.query(["*.txt"])
-    assert len(txt_files) == 1
-    assert txt_files[0].endswith('file2.txt')
-    
-    # 测试多模式查询
-    mixed_files = await cache.query(["*.py", "*.txt"])
-    assert len(mixed_files) == 3
-    assert len([f for f in mixed_files if f.endswith('.py')]) == 2
-    assert len([f for f in mixed_files if f.endswith('.txt')]) == 1
-
-@pytest.mark.asyncio
-async def test_file_change_events(temp_test_dir, mock_file_monitor):
-    """测试文件变更事件处理"""
-    from watchfiles import Change
-    
-    # 创建测试文件结构
-    create_test_environment(temp_test_dir, {
-        "file1.txt": "初始内容"
-    })
-    
-    # 获取实例
-    cache = DirectoryCache.get_instance(temp_test_dir)
-    
-    # 初始状态
-    file_path = os.path.join(temp_test_dir, "file1.txt")
-    abs_file_path = os.path.abspath(file_path)
-    assert abs_file_path in cache.files_set
-    
-    # 测试删除事件
-    await cache._on_change(Change.deleted, abs_file_path)
-    assert abs_file_path not in cache.files_set
-    
-    # 测试添加事件
-    await cache._on_change(Change.added, abs_file_path)
-    assert abs_file_path in cache.files_set
-    
-    # 测试修改事件 (不应改变集合)
-    initial_set_size = len(cache.files_set)
-    await cache._on_change(Change.modified, abs_file_path)
-    assert len(cache.files_set) == initial_set_size
-    assert abs_file_path in cache.files_set
-    
-    # 测试新文件
-    new_file_path = os.path.join(temp_test_dir, "newfile.txt")
-    abs_new_file_path = os.path.abspath(new_file_path)
-    await cache._on_change(Change.added, abs_new_file_path)
-    assert abs_new_file_path in cache.files_set
-
-@pytest.mark.asyncio
-async def test_reinitialization_with_different_root(temp_test_dir, mock_file_monitor):
-    """测试使用不同根目录重新初始化缓存"""
-    # 创建第一个测试目录
-    first_dir = os.path.join(temp_test_dir, "first")
-    os.makedirs(first_dir)
-    create_test_environment(first_dir, {"test.txt": "first directory"})
-    
-    # 初始化缓存
-    cache1 = DirectoryCache.get_instance(first_dir)
-    assert cache1.root == os.path.abspath(first_dir)
-    
-    # 创建第二个测试目录
-    second_dir = os.path.join(temp_test_dir, "second")
-    os.makedirs(second_dir)
-    create_test_environment(second_dir, {"other.txt": "second directory"})
-    
-    # 使用新目录重新初始化
-    cache2 = DirectoryCache.get_instance(second_dir)
-    assert cache2.root == os.path.abspath(second_dir)
-    
-    # 验证文件集合已更新
-    all_files = await cache2.query(["*"])
-    assert len(all_files) == 1
-    assert all_files[0].endswith('other.txt') 

autocoder/common/file_checkpoint/examples.py

@@ -1,217 +0,0 @@
-"""
-文件变更管理模块的使用示例
-
-展示如何使用文件变更管理模块进行文件变更的应用和撤销。
-"""
-
-import os
-import sys
-import json
-from typing import Dict, Any
-
-from autocoder.common.file_checkpoint.models import FileChange
-from autocoder.common.file_checkpoint.manager import FileChangeManager
-
-
-def example_apply_changes(project_dir: str):
-    """
-    示例：应用文件变更
-    
-    Args:
-        project_dir: 项目目录
-    """
-    print(f"示例：应用文件变更到项目 {project_dir}")
-    
-    # 创建文件变更管理器
-    manager = FileChangeManager(project_dir)
-    
-    # 准备文件变更
-    changes = {
-        "example.txt": FileChange(
-            file_path="example.txt",
-            content="这是一个示例文件\n用于演示文件变更管理模块的功能\n",
-            is_new=True
-        ),
-        "README.md": FileChange(
-            file_path="README.md",
-            content="# 示例项目\n\n这是一个用于演示文件变更管理模块的示例项目。\n",
-            is_new=True
-        )
-    }
-    
-    # 应用变更
-    result = manager.apply_changes(changes)
-    
-    # 输出结果
-    if result.success:
-        print(f"成功应用了 {len(result.change_ids)} 个文件变更")
-        for change_id in result.change_ids:
-            print(f"  - 变更ID: {change_id}")
-    else:
-        print("应用变更失败")
-        for file_path, error in result.errors.items():
-            print(f"  - {file_path}: {error}")
-
-
-def example_preview_changes(project_dir: str):
-    """
-    示例：预览文件变更
-    
-    Args:
-        project_dir: 项目目录
-    """
-    print(f"示例：预览文件变更")
-    
-    # 创建文件变更管理器
-    manager = FileChangeManager(project_dir)
-    
-    # 准备文件变更
-    changes = {
-        "example.txt": FileChange(
-            file_path="example.txt",
-            content="这是一个修改后的示例文件\n用于演示文件变更管理模块的功能\n新增的一行\n",
-            is_new=False
-        )
-    }
-    
-    # 预览变更
-    diff_results = manager.preview_changes(changes)
-    
-    # 输出差异
-    for file_path, diff_result in diff_results.items():
-        print(f"\n文件: {file_path}")
-        print(diff_result.get_diff_summary())
-        if diff_result.old_content is not None and not diff_result.is_new and not diff_result.is_deletion:
-            diff_text = manager.get_diff_text(diff_result.old_content, diff_result.new_content)
-            print("\n差异:")
-            print(diff_text)
-
-
-def example_undo_changes(project_dir: str):
-    """
-    示例：撤销文件变更
-    
-    Args:
-        project_dir: 项目目录
-    """
-    print(f"示例：撤销文件变更")
-    
-    # 创建文件变更管理器
-    manager = FileChangeManager(project_dir)
-    
-    # 撤销最近的变更
-    result = manager.undo_last_change()
-    
-    # 输出结果
-    if result.success:
-        print(f"成功撤销了变更，恢复了 {len(result.restored_files)} 个文件")
-        for file_path in result.restored_files:
-            print(f"  - {file_path}")
-    else:
-        print("撤销变更失败")
-        for file_path, error in result.errors.items():
-            print(f"  - {file_path}: {error}")
-
-
-def example_get_history(project_dir: str):
-    """
-    示例：获取变更历史
-    
-    Args:
-        project_dir: 项目目录
-    """
-    print(f"示例：获取变更历史")
-    
-    # 创建文件变更管理器
-    manager = FileChangeManager(project_dir)
-    
-    # 获取变更历史
-    changes = manager.get_change_history(limit=5)
-    
-    # 输出历史记录
-    print(f"最近 {len(changes)} 条变更记录:")
-    for change in changes:
-        timestamp = change.timestamp
-        file_path = change.file_path
-        change_type = "新建" if change.is_new else "删除" if change.is_deletion else "修改"
-        print(f"  - [{timestamp}] {change_type} {file_path} (ID: {change.change_id})")
-
-
-def example_integration_with_agentic_edit():
-    """
-    示例：与 AgenticEdit 集成
-    
-    展示如何将文件变更管理模块集成到 AgenticEdit 中
-    """
-    print("示例：与 AgenticEdit 集成")
-    
-    # 这是一个伪代码示例，展示如何修改 AgenticEdit.apply_changes 方法
-    code = """
-def apply_changes(self):
-    \"\"\"
-    Apply all tracked file changes to the original project directory.
-    \"\"\"
-    from autocoder.common.file_checkpoint.models import FileChange
-    from autocoder.common.file_checkpoint.manager import FileChangeManager
-    
-    # 创建文件变更管理器
-    manager = FileChangeManager(self.args.source_dir)
-    
-    # 将影子系统的变更转换为 FileChange 对象
-    changes = {}
-    for file_path, change in self.get_all_file_changes().items():
-        changes[file_path] = FileChange(
-            file_path=file_path,
-            content=change.content,
-            is_new=not os.path.exists(file_path)
-        )
-    
-    # 应用变更
-    result = manager.apply_changes(changes)
-    
-    # 处理结果
-    if result.success:
-        # 继续执行原有的 Git 提交等逻辑
-        if not self.args.skip_commit:
-            try:
-                # ... 原有的 Git 提交代码 ...
-            except Exception as e:
-                # ... 原有的错误处理 ...
-    else:
-        # 处理应用变更失败的情况
-        error_messages = "\\n".join([f"{path}: {error}" for path, error in result.errors.items()])
-        self.printer.print_str_in_terminal(
-            f"Failed to apply changes:\\n{error_messages}",
-            style="red"
-        )
-    """
-    
-    print(code)
-
-
-def main():
-    """主函数"""
-    if len(sys.argv) < 2:
-        print("用法: python examples.py <项目目录>")
-        return
-    
-    project_dir = sys.argv[1]
-    
-    # 运行示例
-    example_apply_changes(project_dir)
-    print("\n" + "-" * 50 + "\n")
-    
-    example_preview_changes(project_dir)
-    print("\n" + "-" * 50 + "\n")
-    
-    example_get_history(project_dir)
-    print("\n" + "-" * 50 + "\n")
-    
-    example_undo_changes(project_dir)
-    print("\n" + "-" * 50 + "\n")
-    
-    example_integration_with_agentic_edit()
-
-
-if __name__ == "__main__":
-    main()