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

autocoder/common/search_replace_patch/similarity_replacer.py

@@ -0,0 +1,306 @@
+"""
+Similarity-based text replacer implementation
+"""
+
+from typing import List, Tuple
+from loguru import logger
+
+from .base import BaseReplacer, ReplaceResult, ReplaceStrategy
+from ..text_similarity import TextSimilarity
+
+
+class SimilarityReplacer(BaseReplacer):
+    """基于文本相似度的替换器"""
+    
+    def __init__(self, similarity_threshold: float = 0.9):
+        """
+        初始化相似度替换器
+        
+        Args:
+            similarity_threshold: 相似度阈值，超过此值才进行替换
+        """
+        super().__init__(ReplaceStrategy.SIMILARITY)
+        self.similarity_threshold = similarity_threshold
+    
+    def _find_line_numbers(self, content: str, text_block: str) -> Tuple[int, int]:
+        """
+        找到文本块在内容中的行号
+        
+        Args:
+            content: 完整文件内容
+            text_block: 要查找的文本块
+            
+        Returns:
+            Tuple[int, int]: (起始行号, 结束行号)，1-based，如果未找到返回 (-1, -1)
+        """
+        lines = content.splitlines()
+        block_lines = text_block.splitlines()
+        
+        # 找到文本块在内容中的位置
+        block_start_idx = content.find(text_block)
+        if block_start_idx == -1:
+            return (-1, -1)
+        
+        # 计算到文本块开始位置的行数
+        lines_before = content[:block_start_idx].count('\n')
+        start_line = lines_before + 1
+        
+        # 计算文本块的行数
+        lines_in_block = len(block_lines)
+        end_line = start_line + lines_in_block - 1
+        
+        return (start_line, end_line)
+    
+    def _replace_by_line_numbers(self, content: str, start_line: int, end_line: int, 
+                                 replace_text: str) -> str:
+        """
+        根据行号替换文本
+        
+        Args:
+            content: 原始内容
+            start_line: 起始行号（1-based）
+            end_line: 结束行号（1-based）
+            replace_text: 替换的文本
+            
+        Returns:
+            替换后的内容
+        """
+        lines = content.splitlines(keepends=True)
+        
+        # 转换为0-based索引
+        start_idx = start_line - 1
+        end_idx = end_line - 1
+        
+        # 确保索引有效
+        if start_idx < 0 or end_idx >= len(lines) or start_idx > end_idx:
+            return content
+        
+        # 构建新内容
+        new_lines = []
+        new_lines.extend(lines[:start_idx])
+        
+        # 添加替换文本
+        replace_lines = replace_text.splitlines(keepends=True)
+        # 如果替换文本最后没有换行符，但原始文本有，则添加换行符
+        if replace_lines and not replace_lines[-1].endswith('\n') and end_idx < len(lines) - 1:
+            replace_lines[-1] += '\n'
+        new_lines.extend(replace_lines)
+        
+        new_lines.extend(lines[end_idx + 1:])
+        
+        return ''.join(new_lines)
+    
+    def _build_similarity_error_message(self, block_index: int, search_text: str, similarity: float, 
+                                       threshold: float, best_match: str, start_line: int, end_line: int) -> str:
+        """
+        构建针对大模型的详细相似度错误信息
+        """
+        message_parts = []
+        
+        message_parts.append(f"🔍 Block {block_index} Similarity Analysis:")
+        message_parts.append(f"   📏 Found similarity: {similarity:.1%} (threshold: {threshold:.1%})")
+        
+        if similarity > 0.8:
+            message_parts.append(f"   ✅ Very close match found at lines {start_line}-{end_line}")
+            message_parts.append(f"   📝 Expected: {repr(search_text[:80])}{'...' if len(search_text) > 80 else ''}")
+            message_parts.append(f"   📝 Actual:   {repr(best_match[:80])}{'...' if len(best_match) > 80 else ''}")
+            message_parts.append("   💡 Use the exact content shown as 'Actual' in your SEARCH block")
+        elif similarity > 0.6:
+            message_parts.append(f"   ⚠️  Moderate similarity at lines {start_line}-{end_line}")
+            message_parts.append(f"   📝 Your search: {repr(search_text[:60])}{'...' if len(search_text) > 60 else ''}")
+            message_parts.append(f"   📝 Best match:  {repr(best_match[:60])}{'...' if len(best_match) > 60 else ''}")
+            message_parts.append("   💡 Check for whitespace, line ending, or formatting differences")
+        else:
+            message_parts.append(f"   ❌ Low similarity - content may not exist as expected")
+            message_parts.append(f"   📝 Searched for: {repr(search_text[:60])}{'...' if len(search_text) > 60 else ''}")
+            message_parts.append("   💡 Verify the content exists or try a smaller, more unique search phrase")
+        
+        return "\n".join(message_parts)
+    
+    def replace(self, content: str, search_blocks: List[Tuple[str, str]]) -> ReplaceResult:
+        """
+        执行基于相似度的替换（行级替换）
+        
+        Args:
+            content: 原始文件内容
+            search_blocks: 搜索替换块列表
+            
+        Returns:
+            ReplaceResult: 替换结果
+        """
+        if not self.validate_search_blocks(search_blocks):
+            return ReplaceResult(
+                success=False,
+                message="Invalid search blocks provided. 只支持行级替换。",
+                total_count=len(search_blocks)
+            )
+        
+        current_content = content
+        applied_count = 0
+        errors = []
+        similarity_info = []
+        
+        for i, (search_text, replace_text) in enumerate(search_blocks):
+            try:
+                # ----- 插入操作 -----
+                if search_text == "":
+                    # 插入到文件开头
+                    insert_text = replace_text
+                    # 如果插入文本不以换行符结尾，自动补一个，保持行级语义
+                    if not insert_text.endswith(("\n", "\r\n")):
+                        insert_text += "\n"
+                    
+                    current_content = insert_text + current_content
+                    applied_count += 1
+                    logger.info(f"Similarity replacer inserted block {i+1}/{len(search_blocks)} at file head")
+                    continue
+                
+                # ----- 正常替换操作 -----
+                # 硬约束：检查是否为行级替换
+                if not self._is_line_level_search(search_text, content):
+                    error_msg = f"🔍 Block {i+1}: 只支持行级替换\n   📝 Search text: {repr(search_text[:60])}{'...' if len(search_text) > 60 else ''}\n   💡 请确保搜索文本匹配完整行"
+                    errors.append(error_msg)
+                    continue
+                
+                # 使用TextSimilarity查找最佳匹配
+                similarity_finder = TextSimilarity(search_text, current_content)
+                similarity, best_window = similarity_finder.get_best_matching_window()
+                
+                logger.info(f"Block {i+1}: Found similarity {similarity:.3f} with threshold {self.similarity_threshold}")
+                
+                if similarity >= self.similarity_threshold:
+                    # 找到行号
+                    start_line, end_line = self._find_line_numbers(current_content, best_window)
+                    
+                    if start_line > 0 and end_line > 0:
+                        # 执行替换
+                        new_content = self._replace_by_line_numbers(
+                            current_content, start_line, end_line, replace_text
+                        )
+                        
+                        if new_content != current_content:
+                            current_content = new_content
+                            applied_count += 1
+                            similarity_info.append({
+                                'block_index': i + 1,
+                                'similarity': similarity,
+                                'start_line': start_line,
+                                'end_line': end_line,
+                                'matched_text': best_window[:100] + '...' if len(best_window) > 100 else best_window
+                            })
+                            logger.info(f"Applied block {i+1} at lines {start_line}-{end_line}")
+                        else:
+                            error_msg = f"Block {i+1}: Replacement did not change content"
+                            errors.append(error_msg)
+                            logger.warning(error_msg)
+                    else:
+                        error_msg = f"Block {i+1}: Could not determine line numbers for matched text"
+                        errors.append(error_msg)
+                        logger.warning(error_msg)
+                else:
+                    # 构建详细的错误信息给大模型
+                    start_line, end_line = self._find_line_numbers(current_content, best_window)
+                    error_msg = self._build_similarity_error_message(
+                        i + 1, search_text, similarity, self.similarity_threshold, 
+                        best_window, start_line, end_line
+                    )
+                    errors.append(error_msg)
+                    logger.warning(f"Block {i+1}: Similarity {similarity:.3f} below threshold {self.similarity_threshold:.3f}")
+                    
+                    # 提供调试信息
+                    similarity_info.append({
+                        'block_index': i + 1,
+                        'similarity': similarity,
+                        'threshold': self.similarity_threshold,
+                        'best_match': best_window[:100] + '...' if len(best_window) > 100 else best_window,
+                        'location': f"lines {start_line}-{end_line}" if start_line > 0 else "unknown"
+                    })
+                    
+            except Exception as e:
+                error_msg = f"Block {i+1}: Error during similarity matching - {str(e)}"
+                errors.append(error_msg)
+                logger.error(error_msg)
+        
+        success = applied_count > 0
+        
+        if success:
+            if errors:
+                message = f"Partial success: Applied {applied_count}/{len(search_blocks)} blocks with {len(errors)} errors"
+            else:
+                message = f"Success: Applied {applied_count}/{len(search_blocks)} blocks using similarity matching"
+        else:
+            message = f"Failed: No blocks were applied using similarity matching. {len(errors)} errors occurred"
+        
+        return ReplaceResult(
+            success=success,
+            message=message,
+            new_content=current_content if success else None,
+            applied_count=applied_count,
+            total_count=len(search_blocks),
+            errors=errors,
+            metadata={
+                'strategy': self.get_strategy_name(),
+                'similarity_threshold': self.similarity_threshold,
+                'similarity_info': similarity_info
+            }
+        )
+    
+    def can_handle(self, content: str, search_blocks: List[Tuple[str, str]]) -> bool:
+        """
+        检查是否能处理给定的内容和搜索块
+        
+        Args:
+            content: 原始文件内容
+            search_blocks: 搜索替换块列表
+            
+        Returns:
+            bool: 总是返回 True，因为相似度替换器可以处理所有文本
+        """
+        return self.validate_search_blocks(search_blocks)
+    
+    def set_similarity_threshold(self, threshold: float):
+        """
+        设置相似度阈值
+        
+        Args:
+            threshold: 新的相似度阈值 (0.0 - 1.0)
+        """
+        if 0.0 <= threshold <= 1.0:
+            self.similarity_threshold = threshold
+            logger.info(f"Similarity threshold set to {threshold}")
+        else:
+            logger.warning(f"Invalid similarity threshold {threshold}, must be between 0.0 and 1.0")
+    
+    def _is_line_level_search(self, search_text: str, content: str) -> bool:
+        """
+        检查搜索文本是否为行级搜索
+        
+        Args:
+            search_text: 搜索文本
+            content: 文件内容
+            
+        Returns:
+            bool: 是否为行级搜索
+        """
+        # 如果搜索文本包含换行符，认为是多行搜索，允许
+        if '\n' in search_text:
+            return True
+        
+        # 对于单行文本，使用TextSimilarity检查是否能找到完整行匹配
+        try:
+            similarity_finder = TextSimilarity(search_text, content)
+            similarity, best_window = similarity_finder.get_best_matching_window()
+            
+            # 检查最佳匹配是否为完整行
+            if similarity >= self.similarity_threshold:
+                content_lines = content.splitlines()
+                best_window_stripped = best_window.strip()
+                
+                # 检查最佳匹配是否等于某一完整行
+                for line in content_lines:
+                    if line.strip() == best_window_stripped:
+                        return True
+            
+            return False
+        except Exception:
+            return False 

autocoder/common/search_replace_patch/string_replacer.py

@@ -0,0 +1,181 @@
+"""
+String-based text replacer implementation (formerly regex-based)
+"""
+
+from typing import List, Tuple
+from loguru import logger
+
+from .base import BaseReplacer, ReplaceResult, ReplaceStrategy
+
+
+class StringReplacer(BaseReplacer):
+    """基于字符串匹配的文本替换器（严格匹配模式）"""
+    
+    def __init__(self, lenient_mode: bool = False):
+        """
+        初始化字符串替换器
+        
+        Args:
+            lenient_mode: 保留此参数以兼容现有代码，但在严格模式下不生效
+        """
+        super().__init__(ReplaceStrategy.STRING)
+        self.lenient_mode = lenient_mode  # 保留但不使用
+    
+    def _find_line_boundaries(self, content: str, search_text: str) -> List[Tuple[int, int]]:
+        """
+        查找所有匹配的位置，确保是行级匹配
+        
+        Args:
+            content: 文件内容
+            search_text: 搜索文本
+            
+        Returns:
+            匹配位置列表 [(start_pos, end_pos), ...]
+        """
+        matches = []
+        lines = content.splitlines(keepends=True)
+        search_lines = search_text.splitlines()
+        
+        if not search_lines:
+            return matches
+        
+        # 对于单行搜索
+        if len(search_lines) == 1:
+            search_line = search_lines[0]
+            current_pos = 0
+            
+            for i, line in enumerate(lines):
+                line_content = line.rstrip('\r\n')
+                if line_content == search_line:
+                    # 找到匹配的完整行
+                    line_start = current_pos
+                    line_end = current_pos + len(line)
+                    matches.append((line_start, line_end))
+                current_pos += len(line)
+        
+        # 对于多行搜索
+        else:
+            for i in range(len(lines) - len(search_lines) + 1):
+                match_found = True
+                for j, search_line in enumerate(search_lines):
+                    if i + j >= len(lines):
+                        match_found = False
+                        break
+                    line_content = lines[i + j].rstrip('\r\n')
+                    if line_content != search_line:
+                        match_found = False
+                        break
+                
+                if match_found:
+                    # 计算多行匹配的起始和结束位置
+                    start_pos = sum(len(lines[k]) for k in range(i))
+                    end_pos = sum(len(lines[k]) for k in range(i + len(search_lines)))
+                    matches.append((start_pos, end_pos))
+        
+        return matches
+    
+    def replace(self, content: str, search_blocks: List[Tuple[str, str]]) -> ReplaceResult:
+        """
+        执行字符串替换（行级替换）
+        
+        Args:
+            content: 原始文件内容
+            search_blocks: 搜索替换块列表
+            
+        Returns:
+            ReplaceResult: 替换结果
+        """
+        if not self.validate_search_blocks(search_blocks):
+            return ReplaceResult(
+                success=False,
+                message="Invalid search blocks provided",
+                total_count=len(search_blocks)
+            )
+        
+        current_content = content
+        applied_count = 0
+        errors = []
+        
+        for i, (search_text, replace_text) in enumerate(search_blocks):
+            try:
+                # ----- 插入操作 -----
+                if search_text == "":
+                    # 插入到文件开头
+                    insert_text = replace_text
+                    # 如果插入文本不以换行符结尾，自动补一个，保持行级语义
+                    if not insert_text.endswith(("\n", "\r\n")):
+                        insert_text += "\n"
+                    
+                    current_content = insert_text + current_content
+                    applied_count += 1
+                    logger.info(f"String replacer inserted block {i+1}/{len(search_blocks)} at file head")
+                    continue
+                
+                # ----- 正常替换操作 -----
+                # 查找匹配位置（确保行级匹配）
+                matches = self._find_line_boundaries(current_content, search_text)
+                
+                if matches:
+                    # 只替换第一个匹配项，从后往前替换避免位置偏移
+                    start_pos, end_pos = matches[0]
+                    
+                    # 构建替换后的内容
+                    before = current_content[:start_pos]
+                    after = current_content[end_pos:]
+                    
+                    # 处理替换文本的换行符
+                    replacement = replace_text
+                    if '\n' not in search_text and current_content[end_pos-1:end_pos] == '\n':
+                        # 如果原文本是单行且以换行符结尾，替换文本也应该以换行符结尾
+                        if not replacement.endswith(('\n', '\r\n')):
+                            replacement += '\n'
+                    
+                    current_content = before + replacement + after
+                    applied_count += 1
+                    logger.info(f"String replacer applied block {i+1}/{len(search_blocks)}")
+                else:
+                    error_msg = f"🔍 Block {i+1}: No exact line match found\n   📝 Search text: {repr(search_text[:60])}{'...' if len(search_text) > 60 else ''}\n   💡 只支持行级精确匹配，请确保搜索文本完全匹配目标行"
+                    errors.append(error_msg)
+                    logger.warning(f"Block {i+1}: No exact match found for search text")
+                        
+            except Exception as e:
+                error_msg = f"Block {i+1}: Unexpected error - {str(e)}"
+                errors.append(error_msg)
+                logger.error(error_msg)
+        
+        success = applied_count > 0
+        
+        if success:
+            if errors:
+                message = f"Partial success: Applied {applied_count}/{len(search_blocks)} blocks with {len(errors)} errors"
+            else:
+                message = f"Success: Applied {applied_count}/{len(search_blocks)} blocks"
+        else:
+            message = f"Failed: No blocks were applied. {len(errors)} errors occurred"
+        
+        return ReplaceResult(
+            success=success,
+            message=message,
+            new_content=current_content if success else None,
+            applied_count=applied_count,
+            total_count=len(search_blocks),
+            errors=errors,
+            metadata={
+                'strategy': self.get_strategy_name(),
+                'strict_mode': True,  # 现在总是严格模式
+                'lenient_mode': False  # 保留兼容性
+            }
+        )
+    
+    def can_handle(self, content: str, search_blocks: List[Tuple[str, str]]) -> bool:
+        """
+        检查是否能处理给定的内容和搜索块
+        
+        Args:
+            content: 原始文件内容
+            search_blocks: 搜索替换块列表
+            
+        Returns:
+            bool: 总是返回 True，因为字符串替换器可以处理所有文本
+        """
+        return self.validate_search_blocks(search_blocks) 

autocoder/common/search_replace_patch/tests/__init__.py

@@ -0,0 +1,3 @@
+"""
+Tests for Search Replace Patch module
+""" 

autocoder/common/search_replace_patch/tests/run_tests.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""
+Test runner for Search Replace Patch module
+"""
+
+import unittest
+import sys
+import os
+
+# Add the parent directory to the Python path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from .test_base import TestReplaceStrategy, TestReplaceResult, TestBaseReplacer
+from .test_regex_replacer import TestRegexReplacer
+from .test_similarity_replacer import TestSimilarityReplacer
+from .test_patch_replacer import TestPatchReplacer
+from .test_manager import TestSearchReplaceManager
+from .test_integration import TestSearchReplacePatchIntegration
+
+
+def create_test_suite():
+    """Create a test suite with all tests"""
+    suite = unittest.TestSuite()
+    
+    # Add base tests
+    suite.addTest(unittest.makeSuite(TestReplaceStrategy))
+    suite.addTest(unittest.makeSuite(TestReplaceResult))
+    suite.addTest(unittest.makeSuite(TestBaseReplacer))
+    
+    # Add replacer tests
+    suite.addTest(unittest.makeSuite(TestRegexReplacer))
+    suite.addTest(unittest.makeSuite(TestSimilarityReplacer))
+    suite.addTest(unittest.makeSuite(TestPatchReplacer))
+    
+    # Add manager tests
+    suite.addTest(unittest.makeSuite(TestSearchReplaceManager))
+    
+    # Add integration tests
+    suite.addTest(unittest.makeSuite(TestSearchReplacePatchIntegration))
+    
+    return suite
+
+
+def run_specific_test(test_class_name=None, test_method_name=None):
+    """Run a specific test class or method"""
+    if test_class_name:
+        # Map test class names to actual classes
+        test_classes = {
+            'TestReplaceStrategy': TestReplaceStrategy,
+            'TestReplaceResult': TestReplaceResult,
+            'TestBaseReplacer': TestBaseReplacer,
+            'TestRegexReplacer': TestRegexReplacer,
+            'TestSimilarityReplacer': TestSimilarityReplacer,
+            'TestPatchReplacer': TestPatchReplacer,
+            'TestSearchReplaceManager': TestSearchReplaceManager,
+            'TestSearchReplacePatchIntegration': TestSearchReplacePatchIntegration
+        }
+        
+        if test_class_name in test_classes:
+            test_class = test_classes[test_class_name]
+            
+            if test_method_name:
+                # Run specific method
+                suite = unittest.TestSuite()
+                suite.addTest(test_class(test_method_name))
+                return suite
+            else:
+                # Run all methods in the class
+                return unittest.makeSuite(test_class)
+        else:
+            print(f"Test class '{test_class_name}' not found")
+            print(f"Available test classes: {list(test_classes.keys())}")
+            return None
+    else:
+        return create_test_suite()
+
+
+def main():
+    """Main function to run tests"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Run Search Replace Patch tests')
+    parser.add_argument('--test-class', help='Run specific test class')
+    parser.add_argument('--test-method', help='Run specific test method (requires --test-class)')
+    parser.add_argument('--verbose', '-v', action='store_true', help='Verbose output')
+    parser.add_argument('--failfast', '-f', action='store_true', help='Stop on first failure')
+    
+    args = parser.parse_args()
+    
+    # Create test suite
+    suite = run_specific_test(args.test_class, args.test_method)
+    
+    if suite is None:
+        return 1
+    
+    # Configure test runner
+    runner = unittest.TextTestRunner(
+        verbosity=2 if args.verbose else 1,
+        failfast=args.failfast
+    )
+    
+    # Run tests
+    result = runner.run(suite)
+    
+    # Print summary
+    print(f"\nTests run: {result.testsRun}")
+    print(f"Failures: {len(result.failures)}")
+    print(f"Errors: {len(result.errors)}")
+    print(f"Skipped: {len(result.skipped)}")
+    
+    if result.failures:
+        print("\nFailures:")
+        for test, traceback in result.failures:
+            print(f"  {test}: {traceback}")
+    
+    if result.errors:
+        print("\nErrors:")
+        for test, traceback in result.errors:
+            print(f"  {test}: {traceback}")
+    
+    # Return appropriate exit code
+    return 0 if result.wasSuccessful() else 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())