auto-coder 0.1.363__py3-none-any.whl → 0.1.364__py3-none-any.whl

autocoder/events/event_manager_singleton.py

@@ -6,6 +6,7 @@ from datetime import datetime
 import glob
 import json
 import re
+import time
 from pathlib import Path
 import byzerllm
 
@@ -22,6 +23,10 @@ class EventManagerSingleton:
     _default_instance: Optional[EventManager] = None
     _instances: Dict[str, EventManager] = {}
     _lock = threading.RLock()  # 用于线程安全操作的锁
+    _cleanup_thread: Optional[threading.Thread] = None
+    _stop_cleanup = threading.Event()
+    _max_event_files = 100  # 最大保留的事件文件数量
+    _cleanup_interval = 60  # 清理线程执行间隔，单位秒
     
     @classmethod
     def get_instance(cls, event_file: Optional[str] = None) -> EventManager:
@@ -34,15 +39,26 @@ class EventManagerSingleton:
         Returns:
             EventManager: The appropriate EventManager instance
         """
+        # 确保清理线程已启动
+        cls._ensure_cleanup_thread_started()
+        
         if event_file is None:
             # Use default instance logic
             if cls._default_instance is None:
-                cls._default_instance = EventManager(JsonlEventStore(os.path.join(".auto-coder", "events", "events.jsonl")))
+                logger.info("Creating new default EventManager instance.")
+                event_store_path = os.path.join(".auto-coder", "events", "events.jsonl")
+                logger.debug(f"Default EventManager using event store: {event_store_path}")
+                cls._default_instance = EventManager(JsonlEventStore(event_store_path))
+            else:
+                logger.debug("Returning existing default EventManager instance.")
             return cls._default_instance
         
         # If event_file is provided, use it as a key to store/retrieve EventManager instances
         if event_file not in cls._instances:
+            logger.info(f"Creating new EventManager instance for event file: {event_file}")
             cls._instances[event_file] = EventManager(JsonlEventStore(event_file))  
+        else:
+            logger.debug(f"Returning existing EventManager instance for event file: {event_file}")
         
         return cls._instances[event_file]
     
@@ -52,7 +68,11 @@ class EventManagerSingleton:
         重置单例实例。主要用于测试或需要更改事件文件时。
         """
         with cls._lock:
-            cls._default_instance = None
+            if cls._default_instance is not None:
+                logger.info("Resetting default EventManager instance.")
+                cls._default_instance = None
+            else:
+                logger.debug("Default EventManager instance was already None. No reset needed.")
     
     @classmethod
     def set_default_event_file(cls, event_file: str) -> None:
@@ -68,6 +88,110 @@ class EventManagerSingleton:
                 cls._default_event_file = event_file
         else:
             logger.warning("尝试更改默认事件文件，但实例已存在。请先调用reset_instance()。")
+    
+    @classmethod
+    def _ensure_cleanup_thread_started(cls) -> None:
+        """
+        确保清理线程已启动。如果尚未启动，则启动线程。
+        """
+        with cls._lock:
+            if cls._cleanup_thread is None or not cls._cleanup_thread.is_alive():
+                logger.info("启动事件文件清理线程")
+                cls._stop_cleanup.clear()
+                cls._cleanup_thread = threading.Thread(
+                    target=cls._cleanup_event_files_thread,
+                    daemon=True,
+                    name="EventFilesCleanupThread"
+                )
+                cls._cleanup_thread.start()
+    
+    @classmethod
+    def _cleanup_event_files_thread(cls) -> None:
+        """
+        定时清理线程的主函数。定期执行清理操作，确保事件目录只保留最新的指定数量文件。
+        """
+        logger.info(f"事件文件清理线程已启动，将保留最新的{cls._max_event_files}个文件")
+        while not cls._stop_cleanup.is_set():
+            try:
+                cls._cleanup_event_files()
+                # 等待指定时间或直到停止信号
+                cls._stop_cleanup.wait(cls._cleanup_interval)
+            except Exception as e:
+                logger.error(f"事件文件清理过程中发生错误: {e}")
+                # 出错后等待一段时间再重试
+                time.sleep(60)
+    
+    @classmethod
+    def _cleanup_event_files(cls) -> None:
+        """
+        清理事件文件，只保留最新的指定数量文件。
+        """
+        logger.info("开始清理事件文件...")
+        
+        # 确定事件文件所在目录
+        events_dir = os.path.join(os.getcwd(),".auto-coder", "events")
+        
+        # 确保目录存在
+        if not os.path.exists(events_dir):
+            logger.warning(f"事件目录不存在: {events_dir}")
+            return
+        
+        # 获取所有事件文件
+        event_file_pattern = os.path.join(events_dir, "*.jsonl")
+        event_files = glob.glob(event_file_pattern)
+        
+        if not event_files:
+            logger.info(f"未找到任何事件文件: {event_file_pattern}")
+            return
+        
+        # 排除默认的events.jsonl文件
+        event_files = [f for f in event_files if os.path.basename(f) != "events.jsonl"]
+        
+        if len(event_files) <= cls._max_event_files:
+            logger.info(f"事件文件数量({len(event_files)})未超过最大保留数量({cls._max_event_files})，无需清理")
+            return
+        
+        # 解析文件名中的时间戳，格式为 uuid_YYYYMMDD-HHMMSS.jsonl
+        def extract_timestamp(file_path):
+            file_name = os.path.basename(file_path)
+            match = re.search(r'_(\d{8}-\d{6})\.jsonl$', file_name)
+            if match:
+                timestamp_str = match.group(1)
+                try:
+                    return datetime.strptime(timestamp_str, "%Y%m%d-%H%M%S")
+                except ValueError:
+                    return datetime.fromtimestamp(0)  # 默认最早时间
+            return datetime.fromtimestamp(0)  # 默认最早时间
+        
+        # 按时间戳从新到旧排序
+        sorted_files = sorted(event_files, key=extract_timestamp, reverse=True)
+        
+        # 保留最新的文件，删除其余文件
+        files_to_keep = sorted_files[:cls._max_event_files]
+        files_to_delete = sorted_files[cls._max_event_files:]
+        
+        for file_path in files_to_delete:
+            try:
+                os.remove(file_path)
+                logger.info(f"已删除旧事件文件: {file_path}")
+            except Exception as e:
+                logger.error(f"删除事件文件失败 {file_path}: {e}")
+        
+        logger.info(f"事件文件清理完成，删除了{len(files_to_delete)}个旧文件，保留了{len(files_to_keep)}个最新文件")
+    
+    @classmethod
+    def stop_cleanup_thread(cls) -> None:
+        """
+        停止清理线程，通常在应用程序退出时调用。
+        """
+        logger.info("正在停止事件文件清理线程...")
+        cls._stop_cleanup.set()
+        if cls._cleanup_thread and cls._cleanup_thread.is_alive():
+            cls._cleanup_thread.join(timeout=5)
+            if cls._cleanup_thread.is_alive():
+                logger.warning("清理线程未在指定时间内停止")
+            else:
+                logger.info("清理线程已成功停止")
 
 def get_event_file_path(file_id:str,project_path: Optional[str] = None) -> str:
     if project_path is None:
@@ -95,9 +219,12 @@ def gengerate_event_file_path(project_path: Optional[str] = None) -> Tuple[str,s
     
     # 要使用绝对路径，否则会被认为产生两个event_manager
     if project_path is None:
-        return os.path.join(os.getcwd(),".auto-coder", "events", file_name),file_id
+        full_path = os.path.join(os.getcwd(),".auto-coder", "events", file_name)
     else:   
-        return os.path.join(project_path, ".auto-coder", "events", file_name),file_id
+        full_path = os.path.join(project_path, ".auto-coder", "events", file_name)
+    
+    logger.info(f"Generated event file path: {full_path}, file_id: {file_id}")
+    return full_path, file_id
 
 @byzerllm.prompt()
 def _format_events_prompt(event_files: List[Dict]) -> str:
@@ -148,6 +275,7 @@ def to_events_prompt(limit: int = 5, project_path: Optional[str] = None) -> str:
     Returns:
         格式化后的事件提示文本
     """
+    logger.info(f"Generating events prompt with limit={limit}, project_path={project_path}")
     # 确定事件文件所在目录
     if project_path is None:
         events_dir = os.path.join(".auto-coder", "events")
@@ -164,6 +292,7 @@ def to_events_prompt(limit: int = 5, project_path: Optional[str] = None) -> str:
     event_files = glob.glob(event_file_pattern)
     
     if not event_files:
+        logger.info(f"No event files found in pattern: {event_file_pattern}")
         logger.warning(f"未找到任何事件文件: {event_file_pattern}")
         return "未找到任何事件记录。"
     

autocoder/linters/normal_linter.py

@@ -0,0 +1,373 @@
+"""
+用于对文件进行代码检查的模块。
+"""
+
+import os
+import time
+from typing import Dict, List, Any, Optional, Tuple
+from datetime import datetime
+
+from autocoder.linters.linter_factory import LinterFactory
+from autocoder.linters.models import (
+    LintIssue, 
+    FileLintResult, 
+    ProjectLintResult, 
+    IssuePosition, 
+    IssueSeverity
+)
+from loguru import logger as global_logger
+
+class NormalLinter:
+    """
+    用于对文件进行代码检查的类。
+    """
+    
+    def __init__(self, project_dir: str, verbose: bool = False):
+        """
+        初始化。
+        
+        参数:
+            project_dir (str): 项目根目录路径
+            verbose (bool): 是否启用详细输出
+        """
+        self.project_dir = project_dir
+        self.verbose = verbose
+        self.logger = global_logger.bind(name="NormalLinter")
+        
+    def lint_file(self, file_path: str, fix: bool = False) -> FileLintResult:
+        """
+        对单个文件进行代码检查。
+        
+        参数:
+            file_path (str): 文件的路径
+            fix (bool): 是否自动修复问题
+            
+        返回:
+            FileLintResult: 代码检查结果
+        """
+        try:
+            # 记录开始时间以计算执行时间
+            start_time = time.time()
+            
+            # 对文件运行代码检查
+            raw_lint_result = LinterFactory.lint_file(file_path, fix=fix, verbose=self.verbose)
+            
+            # 如果lint过程返回None，创建一个空的结果对象，而不是直接返回None
+            if raw_lint_result is None:
+                language = self._detect_language(file_path)
+                return FileLintResult(
+                    file_path=file_path,
+                    success=False,
+                    language=language,
+                    issues=[],  # 空问题列表
+                    error=None,
+                    error_count=0,
+                    warning_count=0,
+                    info_count=0
+                )
+            
+            # 计算执行时间（毫秒）
+            execution_time_ms = int((time.time() - start_time) * 1000)
+            raw_lint_result['execution_time_ms'] = execution_time_ms
+            
+            # 将原始结果转换为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)}")
+            
+            language = self._detect_language(file_path)
+            return FileLintResult(
+                file_path=file_path,
+                success=False,
+                language=language,
+                error=str(e),
+                issues=[],  # 添加空问题列表
+                error_count=0,
+                warning_count=0,
+                info_count=0
+            )
+    
+    def lint_all_files(self, fix: bool = False) -> ProjectLintResult:
+        """
+        对项目目录中的所有文件进行代码检查。
+        
+        参数:
+            fix (bool): 是否自动修复问题
+            
+        返回:
+            ProjectLintResult: 所有文件的汇总代码检查结果
+        """
+        all_files = self._get_all_files()
+        file_results = {}
+        total_files = len(all_files)
+        files_with_issues = 0
+        total_issues = 0
+        total_errors = 0
+        total_warnings = 0
+        total_infos = 0
+        fixed_issues_count = 0
+        
+        # 处理每个文件
+        for file_path in all_files:
+            self.logger.info(f"正在检查文件: {file_path}")
+            try:
+                file_result = self.lint_file(file_path, fix=fix)
+                self.logger.info(f"检查完成: {file_path}")
+                
+                file_results[file_path] = file_result
+                
+                # 更新统计数据
+                if file_result.success:
+                    issue_count = len(file_result.issues)
+                    if issue_count > 0:
+                        files_with_issues += 1
+                        total_issues += issue_count
+                        total_errors += file_result.error_count
+                        total_warnings += file_result.warning_count
+                        total_infos += file_result.info_count
+                    
+                    if file_result.fixed_issues_count:
+                        fixed_issues_count += file_result.fixed_issues_count
+            except Exception as e:
+                if self.verbose:
+                    import traceback
+                    traceback.print_exc()
+                    print(f"处理 {file_path} 时出错: {str(e)}")
+                
+                language = self._detect_language(file_path)
+                file_results[file_path] = FileLintResult(
+                    file_path=file_path,
+                    success=False,
+                    language=language,
+                    error=str(e),
+                    issues=[],
+                    error_count=0,
+                    warning_count=0,
+                    info_count=0
+                )
+        
+        # 创建项目结果
+        return ProjectLintResult(
+            project_path=self.project_dir,
+            file_results=file_results,
+            total_files=total_files,
+            files_with_issues=files_with_issues,
+            total_issues=total_issues,
+            total_errors=total_errors,
+            total_warnings=total_warnings,
+            total_infos=total_infos,
+            fixed_issues_count=fixed_issues_count if fix else None
+        )
+    
+    def lint_dir(self, directory: str, fix: bool = False) -> ProjectLintResult:
+        """
+        对特定目录中的所有文件进行代码检查。
+        
+        参数:
+            directory (str): 目录的路径
+            fix (bool): 是否自动修复问题
+            
+        返回:
+            ProjectLintResult: 目录中所有文件的汇总代码检查结果
+        """
+        files = self._get_files_in_dir(directory)
+        file_results = {}
+        total_files = len(files)
+        files_with_issues = 0
+        total_issues = 0
+        total_errors = 0
+        total_warnings = 0
+        total_infos = 0
+        fixed_issues_count = 0
+        
+        for file_path in files:
+            try:
+                file_result = self.lint_file(file_path, fix=fix)
+                
+                file_results[file_path] = file_result
+                
+                # 更新统计数据
+                if file_result.success:
+                    issue_count = len(file_result.issues)
+                    if issue_count > 0:
+                        files_with_issues += 1
+                        total_issues += issue_count
+                        total_errors += file_result.error_count
+                        total_warnings += file_result.warning_count
+                        total_infos += file_result.info_count
+                    
+                    if file_result.fixed_issues_count:
+                        fixed_issues_count += file_result.fixed_issues_count
+            except Exception as e:
+                if self.verbose:
+                    print(f"处理 {file_path} 时出错: {str(e)}")
+                
+                language = self._detect_language(file_path)
+                file_results[file_path] = FileLintResult(
+                    file_path=file_path,
+                    success=False,
+                    language=language,
+                    error=str(e),
+                    issues=[],
+                    error_count=0,
+                    warning_count=0,
+                    info_count=0
+                )
+        
+        # 创建项目结果
+        return ProjectLintResult(
+            project_path=directory,
+            file_results=file_results,
+            total_files=total_files,
+            files_with_issues=files_with_issues,
+            total_issues=total_issues,
+            total_errors=total_errors,
+            total_warnings=total_warnings,
+            total_infos=total_infos,
+            fixed_issues_count=fixed_issues_count if fix else None
+        )
+    
+    def _get_all_files(self) -> List[str]:
+        """
+        获取项目目录中的所有文件。
+        
+        返回:
+            List[str]: 文件的绝对路径列表
+        """
+        all_files = []
+        
+        for root, _, files in os.walk(self.project_dir):
+            for file in files:
+                # 跳过隐藏文件和目录
+                if file.startswith('.'):
+                    continue
+                    
+                file_path = os.path.join(root, file)
+                all_files.append(file_path)
+                
+        return all_files
+    
+    def _get_files_in_dir(self, directory: str) -> List[str]:
+        """
+        获取目录及其子目录中的所有文件。
+        
+        参数:
+            directory (str): 目录路径
+            
+        返回:
+            List[str]: 绝对文件路径列表
+        """
+        all_files = []
+        
+        for root, _, files in os.walk(directory):
+            for file in files:
+                # 跳过隐藏文件
+                if file.startswith('.'):
+                    continue
+                    
+                file_path = os.path.join(root, file)
+                all_files.append(file_path)
+                
+        return all_files
+    
+    def _detect_language(self, file_path: str) -> str:
+        """
+        根据文件扩展名检测文件的语言。
+        
+        参数:
+            file_path (str): 文件路径
+            
+        返回:
+            str: 检测到的语言或"unknown"
+        """
+        try:
+            language = LinterFactory._detect_language_from_file(file_path)
+            # 确保返回值是字符串
+            return language if isinstance(language, str) else "unknown"
+        except ValueError:
+            # 如果语言检测失败，返回默认值
+            return "unknown"
+        except Exception:
+            # 捕获所有其他异常并返回默认值
+            return "unknown"
+    
+    def _convert_raw_lint_result(self, raw_result: Dict[str, Any], file_path: str) -> FileLintResult:
+        """
+        将原始的linter输出转换为FileLintResult Pydantic模型。
+        
+        参数:
+            raw_result (Dict[str, Any]): Linter的原始输出
+            file_path (str): 文件的路径
+            
+        返回:
+            FileLintResult: 标准化的lint结果模型
+        """
+        # 提取语言信息
+        language = raw_result.get('language')
+        if not isinstance(language, str):
+            language = self._detect_language(file_path)
+        
+        # 初始化计数器
+        error_count = 0
+        warning_count = 0
+        info_count = 0
+        
+        # 处理问题
+        issues = []
+        raw_issues = raw_result.get('issues', [])
+        
+        for raw_issue in raw_issues:
+            # 确定严重性
+            severity_str = raw_issue.get('severity', 'error').lower()
+            if severity_str in ('error', 'critical', 'fatal'):
+                severity = IssueSeverity.ERROR
+                error_count += 1
+            elif severity_str in ('warning', 'warn'):
+                severity = IssueSeverity.WARNING
+                warning_count += 1
+            else:
+                severity = IssueSeverity.INFO
+                info_count += 1
+                
+            # 提取位置信息
+            line = raw_issue.get('line', 1)
+            column = raw_issue.get('column')
+            end_line = raw_issue.get('end_line')
+            end_column = raw_issue.get('end_column')
+            
+            position = IssuePosition(
+                line=line,
+                column=column,
+                end_line=end_line,
+                end_column=end_column
+            )
+            
+            # 创建问题
+            issue = LintIssue(
+                code=raw_issue.get('code', ''),
+                message=raw_issue.get('message', '未知问题'),
+                severity=severity,
+                position=position,
+                file_path=file_path,
+                rule_name=raw_issue.get('rule_name'),
+                source=raw_issue.get('source'),
+                fix_available=raw_issue.get('fix_available', False),
+                fix_description=raw_issue.get('fix_description')
+            )
+            
+            issues.append(issue)
+        
+        # 创建文件结果
+        return FileLintResult(
+            file_path=file_path,
+            success=raw_result.get('success', True),
+            language=language,
+            issues=issues,
+            error=raw_result.get('error'),
+            warning_count=warning_count,
+            error_count=error_count,
+            info_count=info_count,
+            execution_time_ms=raw_result.get('execution_time_ms'),
+            fixed_issues_count=raw_result.get('fixed_issues_count')
+        )

autocoder/linters/python_linter.py

@@ -11,6 +11,7 @@ import tempfile
 from typing import Dict, List, Any, Optional, Tuple
 
 from autocoder.linters.base_linter import BaseLinter
+from loguru import logger
 
 class PythonLinter(BaseLinter):
     """
@@ -142,6 +143,8 @@ class PythonLinter(BaseLinter):
             'warning_count': 0,
             'issues': []
         }
+
+        logger.info(f"Running pylint on {target}")
         
         try:
             # Create a temp file to store JSON output
@@ -152,8 +155,7 @@ class PythonLinter(BaseLinter):
             cmd = [
                 sys.executable, 
                 "-m", 
-                "pylint", 
-                "--disable=import-error",
+                "pylint",                 
                 "--output-format=json", 
                 target
             ]

autocoder/version.py

@@ -1 +1 @@
-__version__ = "0.1.363"
+__version__ = "0.1.364"