auto-coder 0.1.373__tar.gz → 0.1.374__tar.gz

{auto_coder-0.1.373 → auto_coder-0.1.374}/PKG-INFO

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

{auto_coder-0.1.373 → auto_coder-0.1.374}/src/auto_coder.egg-info/PKG-INFO

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

{auto_coder-0.1.373 → auto_coder-0.1.374}/src/autocoder/common/v2/agent/agentic_edit_tools/replace_in_file_tool_resolver.py

@@ -7,6 +7,7 @@ from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import Base
 from autocoder.common.v2.agent.agentic_edit_types import ReplaceInFileTool, ToolResult
 from autocoder.common.file_checkpoint.models import FileChange as CheckpointFileChange
 from autocoder.common.file_checkpoint.manager import FileChangeManager as CheckpointFileChangeManager
+from autocoder.linters.models import IssueSeverity, FileLintResult
 from loguru import logger
 from autocoder.common.auto_coder_lang import get_message_with_format
 if typing.TYPE_CHECKING:
@@ -62,7 +63,38 @@ class ReplaceInFileToolResolver(BaseToolResolver):
             logger.warning(f"Could not parse any SEARCH/REPLACE blocks from diff: {diff_content}")
         return blocks
 
-    def _format_lint_issues(self, lint_result):
+    def _filter_lint_issues(self, lint_result:FileLintResult, levels: List[IssueSeverity] = [IssueSeverity.ERROR, IssueSeverity.WARNING]):
+        """
+        过滤 lint 结果，只保留指定级别的问题
+        
+        参数:
+            lint_result: 单个文件的 lint 结果对象
+            levels: 要保留的问题级别列表，默认保留 ERROR 和 WARNING 级别
+            
+        返回:
+            过滤后的 lint 结果对象（原对象的副本）
+        """
+        if not lint_result or not lint_result.issues:
+            return lint_result
+            
+        # 创建一个新的 issues 列表，只包含指定级别的问题
+        filtered_issues = []
+        for issue in lint_result.issues:
+            if issue.severity in levels:                
+                filtered_issues.append(issue)
+                
+        # 更新 lint_result 的副本
+        filtered_result = lint_result
+        filtered_result.issues = filtered_issues
+        
+        # 更新计数
+        filtered_result.error_count = sum(1 for issue in filtered_result.issues if issue.severity == IssueSeverity.ERROR)
+        filtered_result.warning_count = sum(1 for issue in filtered_result.issues if issue.severity == IssueSeverity.WARNING)
+        filtered_result.info_count = sum(1 for issue in filtered_result.issues if issue.severity == IssueSeverity.INFO)
+        
+        return filtered_result
+        
+    def _format_lint_issues(self, lint_result:FileLintResult):
         """
         将 lint 结果格式化为可读的文本格式
         
@@ -86,130 +118,7 @@ class ReplaceInFileToolResolver(BaseToolResolver):
         
         return "\n".join(formatted_issues)
 
-    def replace_in_file_with_shadow(self, file_path: str, diff_content: str, source_dir: str, abs_project_dir: str, abs_file_path: str) -> ToolResult:
-        """Replace content in file using shadow manager for path translation"""
-        try:
-            # Determine target path: shadow file
-            target_path = self.shadow_manager.to_shadow_path(abs_file_path)
-
-            # Read original content
-            if os.path.exists(target_path) and os.path.isfile(target_path):
-                with open(target_path, 'r', encoding='utf-8', errors='replace') as f:
-                    original_content = f.read()
-            elif os.path.exists(abs_file_path) and os.path.isfile(abs_file_path):
-                # If shadow doesn't exist, but original exists, read original content
-                with open(abs_file_path, 'r', encoding='utf-8', errors='replace') as f:
-                    original_content = f.read()
-                # create parent dirs of shadow if needed
-                os.makedirs(os.path.dirname(target_path), exist_ok=True)
-                # write original content into shadow file as baseline
-                with open(target_path, 'w', encoding='utf-8') as f:
-                    f.write(original_content)
-                logger.info(f"[Shadow] Initialized shadow file from original: {target_path}")
-            else:
-                return ToolResult(success=False, message=get_message_with_format("replace_in_file.file_not_found", file_path=file_path))
-
-            parsed_blocks = self.parse_diff(diff_content)
-            if not parsed_blocks:
-                return ToolResult(success=False, message=get_message_with_format("replace_in_file.no_valid_blocks"))
-
-            current_content = original_content
-            applied_count = 0
-            errors = []
-
-            # Apply blocks sequentially
-            for i, (search_block, replace_block) in enumerate(parsed_blocks):
-                start_index = current_content.find(search_block)
-
-                if start_index != -1:
-                    current_content = current_content[:start_index] + replace_block + current_content[start_index + len(search_block):]
-                    applied_count += 1
-                    logger.info(f"Applied SEARCH/REPLACE block {i+1} in file {file_path}")
-                else:
-                    error_message = f"SEARCH block {i+1} not found in the current file content. Content to search:\n---\n{search_block}\n---"
-                    logger.warning(error_message)
-                    context_start = max(0, original_content.find(search_block[:20]) - 100)
-                    context_end = min(len(original_content), context_start + 200 + len(search_block[:20]))
-                    logger.warning(f"Approximate context in file:\n---\n{original_content[context_start:context_end]}\n---")
-                    errors.append(error_message)
-
-            if applied_count == 0 and errors:
-                return ToolResult(success=False, message=get_message_with_format("replace_in_file.apply_failed", errors="\n".join(errors)))
-
-            # Write the modified content back to shadow file
-            os.makedirs(os.path.dirname(target_path), exist_ok=True)
-            with open(target_path, 'w', encoding='utf-8') as f:
-                f.write(current_content)
-            
-            logger.info(f"Successfully applied {applied_count}/{len(parsed_blocks)} changes to shadow file: {file_path}")
-
-            # 新增：执行代码质量检查
-            lint_results = None
-            lint_message = ""
-            formatted_issues = ""
-            has_lint_issues = False
-            
-            # 检查是否启用了Lint功能
-            enable_lint = self.args.enable_auto_fix_lint
-            
-            if enable_lint:
-                try:
-                    if self.shadow_linter and self.shadow_manager:
-                        # 对修改后的文件进行 lint 检查
-                        shadow_path = target_path  # 已经是影子路径
-                        lint_results = self.shadow_linter.lint_shadow_file(shadow_path)
-                        
-                        if lint_results and lint_results.issues:
-                            has_lint_issues = True
-                            # 格式化 lint 问题
-                            formatted_issues = self._format_lint_issues(lint_results)
-                            lint_message = f"\n\n代码质量检查发现 {len(lint_results.issues)} 个问题:\n{formatted_issues}"
-                        else:
-                            lint_message = "\n\n代码质量检查通过，未发现问题。"
-                except Exception as e:
-                    logger.error(f"Lint 检查失败: {str(e)}")
-                    lint_message = "\n\n尝试进行代码质量检查时出错。"
-            else:
-                logger.info("代码质量检查已禁用")
-
-            # 构建包含 lint 结果的返回消息
-            if errors:
-                message = get_message_with_format("replace_in_file.apply_success_with_warnings", 
-                                                  applied=applied_count, 
-                                                  total=len(parsed_blocks), 
-                                                  file_path=file_path,
-                                                  errors="\n".join(errors))
-            else:
-                message = get_message_with_format("replace_in_file.apply_success", 
-                                                  applied=applied_count, 
-                                                  total=len(parsed_blocks), 
-                                                  file_path=file_path)
-            
-            # 将 lint 消息添加到结果中，如果启用了Lint
-            if enable_lint:
-                message += lint_message
-
-            # 变更跟踪，回调AgenticEdit
-            if self.agent:
-                rel_path = os.path.relpath(abs_file_path, abs_project_dir)
-                self.agent.record_file_change(rel_path, "modified", diff=diff_content, content=current_content)
-
-            # 附加 lint 结果到返回内容
-            result_content = {
-                "content": current_content,
-            }
-            
-            # 只有在启用Lint时才添加Lint结果
-            if enable_lint:
-                result_content["lint_results"] = {
-                    "has_issues": has_lint_issues,
-                    "issues": formatted_issues if has_lint_issues else None
-                }
-
-            return ToolResult(success=True, message=message, content=result_content)
-        except Exception as e:
-            logger.error(f"Error writing replaced content to shadow file '{file_path}': {str(e)}")
-            return ToolResult(success=False, message=get_message_with_format("replace_in_file.write_error", error=str(e)))
+    
 
     def replace_in_file_normal(self, file_path: str, diff_content: str, source_dir: str, abs_project_dir: str, abs_file_path: str) -> ToolResult:
         """Replace content in file directly without using shadow manager"""
@@ -282,16 +191,20 @@ class ReplaceInFileToolResolver(BaseToolResolver):
             
             # 检查是否启用了Lint功能
             enable_lint = self.args.enable_auto_fix_lint
+            logger.info(f"检查Lint功能状态: enable_lint={enable_lint}")
             
             if enable_lint:
                 try:
                     if self.agent.linter:
                         lint_results = self.agent.linter.lint_file(file_path)
                         if lint_results and lint_results.issues:
-                            has_lint_issues = True
-                            # 格式化 lint 问题
-                            formatted_issues = self._format_lint_issues(lint_results)
-                            lint_message = f"\n\n代码质量检查发现 {len(lint_results.issues)} 个问题:\n{formatted_issues}"
+                            # 过滤 lint 结果，只保留 ERROR 和 WARNING 级别的问题
+                            filtered_results = self._filter_lint_issues(lint_results)
+                            if filtered_results.issues:
+                                has_lint_issues = True
+                                # 格式化 lint 问题
+                                formatted_issues = self._format_lint_issues(filtered_results)
+                                lint_message = f"\n\n代码质量检查发现 {len(filtered_results.issues)} 个问题"
                 except Exception as e:
                     logger.error(f"Lint 检查失败: {str(e)}")
                     lint_message = "\n\n尝试进行代码质量检查时出错。"
@@ -309,17 +222,13 @@ class ReplaceInFileToolResolver(BaseToolResolver):
                 message = get_message_with_format("replace_in_file.apply_success", 
                                                   applied=applied_count, 
                                                   total=len(parsed_blocks), 
-                                                  file_path=file_path)
-            
-            # 将 lint 消息添加到结果中，如果启用了Lint
-            if enable_lint:
-                message += lint_message
+                                                  file_path=file_path)                        
 
             # 变更跟踪，回调AgenticEdit
             if self.agent:
                 rel_path = os.path.relpath(abs_file_path, abs_project_dir)
                 self.agent.record_file_change(rel_path, "modified", diff=diff_content, content=current_content)
-
+                        
             # 附加 lint 结果到返回内容
             result_content = {
                 "content": current_content,
@@ -327,6 +236,7 @@ class ReplaceInFileToolResolver(BaseToolResolver):
             
             # 只有在启用Lint时才添加Lint结果
             if enable_lint:
+                message = message + "\n" + lint_message
                 result_content["lint_results"] = {
                     "has_issues": has_lint_issues,
                     "issues": formatted_issues if has_lint_issues else None
@@ -348,9 +258,5 @@ class ReplaceInFileToolResolver(BaseToolResolver):
         # Security check
         if not abs_file_path.startswith(abs_project_dir):
             return ToolResult(success=False, message=get_message_with_format("replace_in_file.access_denied", file_path=file_path))
-
-        # Choose the appropriate implementation based on whether shadow_manager is available
-        if self.shadow_manager:
-            return self.replace_in_file_with_shadow(file_path, diff_content, source_dir, abs_project_dir, abs_file_path)
-        else:
-            return self.replace_in_file_normal(file_path, diff_content, source_dir, abs_project_dir, abs_file_path)
+                
+        return self.replace_in_file_normal(file_path, diff_content, source_dir, abs_project_dir, abs_file_path)

{auto_coder-0.1.373 → auto_coder-0.1.374}/src/autocoder/common/v2/agent/agentic_edit_tools/write_to_file_tool_resolver.py

@@ -1,5 +1,5 @@
 import os
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, List
 from autocoder.common.v2.agent.agentic_edit_types import WriteToFileTool, ToolResult
 from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
 from loguru import logger
@@ -7,6 +7,7 @@ from autocoder.common import AutoCoderArgs
 from autocoder.common.auto_coder_lang import get_message_with_format
 from autocoder.common.file_checkpoint.models import FileChange as CheckpointFileChange
 from autocoder.common.file_checkpoint.manager import FileChangeManager as CheckpointFileChangeManager
+from autocoder.linters.models import IssueSeverity, FileLintResult
 import typing
 
 if typing.TYPE_CHECKING:
@@ -20,7 +21,38 @@ class WriteToFileToolResolver(BaseToolResolver):
         self.shadow_manager = self.agent.shadow_manager if self.agent else None
         self.shadow_linter = self.agent.shadow_linter if self.agent else None
         
-    def _format_lint_issues(self, lint_result):
+    def _filter_lint_issues(self, lint_result:FileLintResult, levels: List[IssueSeverity] = [IssueSeverity.ERROR, IssueSeverity.WARNING]):
+        """
+        过滤 lint 结果，只保留指定级别的问题
+        
+        参数:
+            lint_result: 单个文件的 lint 结果对象
+            levels: 要保留的问题级别列表，默认保留 ERROR 和 WARNING 级别
+            
+        返回:
+            过滤后的 lint 结果对象（原对象的副本）
+        """
+        if not lint_result or not lint_result.issues:
+            return lint_result
+            
+        # 创建一个新的 issues 列表，只包含指定级别的问题
+        filtered_issues = []
+        for issue in lint_result.issues:
+            if issue.severity in levels:
+                filtered_issues.append(issue)
+                
+        # 更新 lint_result 的副本
+        filtered_result = lint_result
+        filtered_result.issues = filtered_issues
+        
+        # 更新计数
+        filtered_result.error_count = sum(1 for issue in filtered_issues if issue.severity == IssueSeverity.ERROR)
+        filtered_result.warning_count = sum(1 for issue in filtered_issues if issue.severity == IssueSeverity.WARNING)
+        filtered_result.info_count = sum(1 for issue in filtered_issues if issue.severity == IssueSeverity.INFO)
+        
+        return filtered_result
+        
+    def _format_lint_issues(self, lint_result:FileLintResult):
         """
         将 lint 结果格式化为可读的文本格式
         
@@ -43,74 +75,7 @@ class WriteToFileToolResolver(BaseToolResolver):
             )
         
         return "\n".join(formatted_issues)
-
-    def write_file_with_shadow(self, file_path: str, content: str, source_dir: str, abs_project_dir: str, abs_file_path: str) -> ToolResult:
-        """Write file using shadow manager for path translation"""
-        try:
-            shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
-            # Ensure shadow directory exists
-            os.makedirs(os.path.dirname(shadow_path), exist_ok=True)
-            with open(shadow_path, 'w', encoding='utf-8') as f:
-                f.write(content)
-            logger.info(f"[Shadow] Successfully wrote shadow file: {shadow_path}")
-
-            # 回调AgenticEdit，记录变更
-            if self.agent:
-                rel_path = os.path.relpath(abs_file_path, abs_project_dir)
-                self.agent.record_file_change(rel_path, "added", diff=None, content=content)
-            
-            # 新增：执行代码质量检查
-            lint_results = None
-            lint_message = ""
-            formatted_issues = ""
-            has_lint_issues = False
-            
-            # 检查是否启用了Lint功能
-            enable_lint = self.args.enable_auto_fix_lint
-            
-            if enable_lint:
-                try:
-                    if self.shadow_linter and self.shadow_manager:
-                        # 对新创建的文件进行 lint 检查
-                        shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
-                        lint_results = self.shadow_linter.lint_shadow_file(shadow_path)
-                        
-                        if lint_results and lint_results.issues:
-                            has_lint_issues = True
-                            # 格式化 lint 问题
-                            formatted_issues = self._format_lint_issues(lint_results)
-                            lint_message = f"\n\n代码质量检查发现 {len(lint_results.issues)} 个问题:\n{formatted_issues}"
-                        else:
-                            lint_message = "\n\n代码质量检查通过，未发现问题。"
-                except Exception as e:
-                    logger.error(f"Lint 检查失败: {str(e)}")
-                    lint_message = "\n\n尝试进行代码质量检查时出错。"
-            else:
-                logger.info("代码质量检查已禁用")
-            
-            # 构建包含 lint 结果的返回消息
-            message = f"Successfully wrote to file (shadow): {file_path}"
-            
-            # 将 lint 消息添加到结果中，如果启用了Lint
-            if enable_lint:
-                message += lint_message
-            
-            # 附加 lint 结果到返回内容
-            result_content = {
-                "content": content,
-            }
-            
-            # 只有在启用Lint时才添加Lint结果
-            if enable_lint:
-                result_content["lint_results"] = {
-                    "has_issues": has_lint_issues,
-                    "issues": formatted_issues if has_lint_issues else None
-                }
-            
-            return ToolResult(success=True, message=message, content=result_content)
-        except Exception as e:
-            logger.error(f"Error writing to shadow file '{file_path}': {str(e)}")
-            return ToolResult(success=False, message=f"An error occurred while writing to the shadow file: {str(e)}")
+    
 
     def write_file_normal(self, file_path: str, content: str, source_dir: str, abs_project_dir: str, abs_file_path: str) -> ToolResult:
         """Write file directly without using shadow manager"""
@@ -153,31 +118,17 @@ class WriteToFileToolResolver(BaseToolResolver):
             enable_lint = self.args.enable_auto_fix_lint
             
             if enable_lint:
-                try:
-                    if self.shadow_linter and self.shadow_manager:
-                        # 对新创建的文件进行 lint 检查
-                        # 由于没有shadow系统，需要先创建shadow文件
-                        shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
-                        os.makedirs(os.path.dirname(shadow_path), exist_ok=True)
-                        with open(shadow_path, 'w', encoding='utf-8') as f:
-                            f.write(content)
-                        
-                        lint_results = self.shadow_linter.lint_shadow_file(shadow_path)
-                        
-                        if lint_results and lint_results.issues:
-                            has_lint_issues = True
-                            # 格式化 lint 问题
-                            formatted_issues = self._format_lint_issues(lint_results)
-                            lint_message = f"\n\n代码质量检查发现 {len(lint_results.issues)} 个问题:\n{formatted_issues}"
-                        else:
-                            lint_message = "\n\n代码质量检查通过，未发现问题。"
+                try:                    
                     if self.agent.linter:
                         lint_results = self.agent.linter.lint_file(file_path)
                         if lint_results and lint_results.issues:
-                            has_lint_issues = True
-                            # 格式化 lint 问题
-                            formatted_issues = self._format_lint_issues(lint_results)
-                            lint_message = f"\n\n代码质量检查发现 {len(lint_results.issues)} 个问题:\n{formatted_issues}"
+                            # 过滤 lint 结果，只保留 ERROR 和 WARNING 级别的问题
+                            filtered_results = self._filter_lint_issues(lint_results)
+                            if filtered_results.issues:
+                                has_lint_issues = True
+                                # 格式化 lint 问题
+                                formatted_issues = self._format_lint_issues(filtered_results)
+                                lint_message = f"\n\n代码质量检查发现 {len(filtered_results.issues)} 个问题"
                 except Exception as e:
                     logger.error(f"Lint 检查失败: {str(e)}")
                     lint_message = "\n\n尝试进行代码质量检查时出错。"
@@ -186,10 +137,7 @@ class WriteToFileToolResolver(BaseToolResolver):
             
             # 构建包含 lint 结果的返回消息
             message = f"{file_path}"
-            
-            # 将 lint 消息添加到结果中，如果启用了Lint
-            if enable_lint:
-                message += lint_message
+                        
             
             # 附加 lint 结果到返回内容
             result_content = {
@@ -198,6 +146,7 @@ class WriteToFileToolResolver(BaseToolResolver):
             
             # 只有在启用Lint时才添加Lint结果
             if enable_lint:
+                message = message + "\n" + lint_message
                 result_content["lint_results"] = {
                     "has_issues": has_lint_issues,
                     "issues": formatted_issues if has_lint_issues else None
@@ -219,9 +168,5 @@ class WriteToFileToolResolver(BaseToolResolver):
         # Security check: ensure the path is within the source directory
         if not abs_file_path.startswith(abs_project_dir):
             return ToolResult(success=False, message=f"Error: Access denied. Attempted to write file outside the project directory: {file_path}")
-
-        # Choose the appropriate implementation based on whether shadow_manager is available
-        if self.shadow_manager:
-            return self.write_file_with_shadow(file_path, content, source_dir, abs_project_dir, abs_file_path)
-        else:
-            return self.write_file_normal(file_path, content, source_dir, abs_project_dir, abs_file_path)
+                
+        return self.write_file_normal(file_path, content, source_dir, abs_project_dir, abs_file_path)

{auto_coder-0.1.373 → auto_coder-0.1.374}/src/autocoder/index/index.py

@@ -665,7 +665,7 @@ class IndexManager:
                     md5=data["md5"],
                 )
                 index_items.append(index_item)
-            except (KeyError, TypeError) as e:
+            except Exception as e:
                 logger.warning(f"处理索引条目 {module_name} 时出错: {str(e)}")
                 logger.exception(e)
                 continue

{auto_coder-0.1.373 → auto_coder-0.1.374}/src/autocoder/linters/linter_factory.py

@@ -9,6 +9,7 @@ from autocoder.linters.base_linter import BaseLinter
 from autocoder.linters.reactjs_linter import ReactJSLinter
 from autocoder.linters.vue_linter import VueLinter
 from autocoder.linters.python_linter import PythonLinter
+from loguru import logger
 
 class LinterFactory:
     """
@@ -115,9 +116,11 @@ class LinterFactory:
         Returns:
             Dict[str, Any]: Lint results.
         """
+        logger.info(f"根据文件路径{file_path}自动查找 linter")
         linter = cls.create_linter(file_path=file_path, verbose=verbose)
+        logger.info(f"Linting file: {file_path} with linter: {linter.__class__.__name__}")
         if linter is None:
-            return None
+            return None        
         return linter.lint_file(file_path, fix=fix)
     
     @classmethod

{auto_coder-0.1.373 → auto_coder-0.1.374}/src/autocoder/linters/normal_linter.py

@@ -72,10 +72,8 @@ class NormalLinter:
             
             # 将原始结果转换为Pydantic模型
             return self._convert_raw_lint_result(raw_lint_result, file_path)
-        except Exception as e:
-            if self.verbose:
-                print(f"检查 {file_path} 时出错: {str(e)}")
-            
+        except Exception as e:            
+            self.logger.exception(f"检查 {file_path} 时出错: {e}")            
             language = self._detect_language(file_path)
             return FileLintResult(
                 file_path=file_path,