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

autocoder/common/v2/agent/agentic_edit_tools/extract_to_text_tool_resolver.py

@@ -0,0 +1,225 @@
+import os
+import tempfile
+import requests
+from typing import Optional
+from pathlib import Path
+from urllib.parse import urlparse
+from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder.common.v2.agent.agentic_edit_types import ExtractToTextTool, ToolResult
+from autocoder.common import AutoCoderArgs
+from loguru import logger
+import typing
+
+# 导入文档解析相关模块
+from autocoder.rag.loaders import (
+    extract_text_from_pdf,
+    extract_text_from_docx,
+    extract_text_from_ppt
+)
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.agent.agentic_edit import AgenticEdit
+
+
+class ExtractToTextToolResolver(BaseToolResolver):
+    """文本提取工具解析器，将各种格式文件转换为文本文件"""
+    
+    def __init__(self, agent: Optional['AgenticEdit'], tool: ExtractToTextTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: ExtractToTextTool = tool  # 类型提示
+
+    def _is_url(self, path: str) -> bool:
+        """检查路径是否为URL"""
+        try:
+            result = urlparse(path)
+            return all([result.scheme, result.netloc])
+        except Exception:
+            return False
+
+    def _download_from_url(self, url: str) -> str:
+        """从URL下载文件到临时路径"""
+        try:
+            logger.info(f"Downloading file from URL: {url}")
+            response = requests.get(url, timeout=30)
+            response.raise_for_status()
+            
+            # 从URL或Content-Disposition头获取文件名
+            filename = None
+            if 'content-disposition' in response.headers:
+                content_disposition = response.headers['content-disposition']
+                if 'filename=' in content_disposition:
+                    filename = content_disposition.split('filename=')[1].strip('"')
+            
+            if not filename:
+                # 从URL路径提取文件名
+                parsed_url = urlparse(url)
+                filename = os.path.basename(parsed_url.path)
+                if not filename or '.' not in filename:
+                    # 根据Content-Type猜测扩展名
+                    content_type = response.headers.get('content-type', '')
+                    if 'pdf' in content_type:
+                        filename = 'downloaded_file.pdf'
+                    elif 'word' in content_type or 'officedocument' in content_type:
+                        filename = 'downloaded_file.docx'
+                    elif 'powerpoint' in content_type or 'presentation' in content_type:
+                        filename = 'downloaded_file.pptx'
+                    else:
+                        filename = 'downloaded_file.txt'
+            
+            # 创建临时文件
+            temp_dir = tempfile.mkdtemp()
+            temp_file_path = os.path.join(temp_dir, filename)
+            
+            with open(temp_file_path, 'wb') as temp_file:
+                temp_file.write(response.content)
+            
+            logger.info(f"Downloaded file to: {temp_file_path}")
+            return temp_file_path
+            
+        except Exception as e:
+            raise Exception(f"Failed to download file from URL '{url}': {str(e)}")
+
+    def _extract_text_content(self, file_path: str) -> str:
+        """提取文件的文本内容，支持多种格式"""
+        try:
+            ext = os.path.splitext(file_path)[1].lower()
+            
+            if ext == '.pdf':
+                logger.info(f"Extracting text from PDF: {file_path}")
+                return extract_text_from_pdf(file_path)
+            elif ext == '.docx':
+                logger.info(f"Extracting text from DOCX: {file_path}")
+                return extract_text_from_docx(file_path)
+            elif ext in ('.pptx', '.ppt'):
+                logger.info(f"Extracting text from PPT/PPTX: {file_path}")
+                slide_texts = []
+                for slide_identifier, slide_text_content in extract_text_from_ppt(file_path):
+                    slide_texts.append(f"--- Slide {slide_identifier} ---\n{slide_text_content}")
+                return "\n\n".join(slide_texts) if slide_texts else ""
+            else:
+                # 处理普通文本文件
+                logger.info(f"Reading plain text file: {file_path}")
+                with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
+                    return f.read()
+                    
+        except Exception as e:
+            raise Exception(f"Failed to extract text from file '{file_path}': {str(e)}")
+
+    def _write_text_to_file(self, content: str, target_path: str) -> None:
+        """将文本内容写入目标文件"""
+        try:
+            # 确保目标目录存在
+            target_dir = os.path.dirname(target_path)
+            if target_dir:
+                os.makedirs(target_dir, exist_ok=True)
+            
+            # 写入文件
+            with open(target_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+            
+            logger.info(f"Successfully wrote text content to: {target_path}")
+            
+        except Exception as e:
+            raise Exception(f"Failed to write text to file '{target_path}': {str(e)}")
+
+    def _cleanup_temp_file(self, temp_path: str) -> None:
+        """清理临时文件"""
+        try:
+            if os.path.exists(temp_path):
+                # 如果是临时目录中的文件，删除整个临时目录
+                temp_dir = os.path.dirname(temp_path)
+                if temp_dir.startswith(tempfile.gettempdir()):
+                    import shutil
+                    shutil.rmtree(temp_dir, ignore_errors=True)
+                    logger.info(f"Cleaned up temporary directory: {temp_dir}")
+                else:
+                    os.remove(temp_path)
+                    logger.info(f"Cleaned up temporary file: {temp_path}")
+        except Exception as e:
+            logger.warning(f"Failed to cleanup temporary file '{temp_path}': {str(e)}")
+
+    def resolve(self) -> ToolResult:
+        """
+        执行文本提取工具
+        
+        Returns:
+            ToolResult: 工具执行结果
+        """
+        source_path = self.tool.source_path
+        target_path = self.tool.target_path
+        temp_file_path = None
+        
+        try:
+            # 第一步：获取源文件路径
+            if self._is_url(source_path):
+                # 从URL下载文件
+                temp_file_path = self._download_from_url(source_path)
+                actual_source_path = temp_file_path
+                logger.info(f"Processing URL: {source_path} -> {temp_file_path}")
+            else:
+                # 本地文件路径
+                if not os.path.exists(source_path):
+                    return ToolResult(
+                        success=False,
+                        message=f"Error: Source file not found at path: {source_path}"
+                    )
+                if not os.path.isfile(source_path):
+                    return ToolResult(
+                        success=False,
+                        message=f"Error: Source path is not a file: {source_path}"
+                    )
+                actual_source_path = source_path
+                logger.info(f"Processing local file: {source_path}")
+
+            # 第二步：提取文本内容
+            text_content = self._extract_text_content(actual_source_path)
+            
+            if not text_content.strip():
+                return ToolResult(
+                    success=False,
+                    message=f"Warning: No text content extracted from file: {source_path}"
+                )
+
+            # 第三步：写入目标文件
+            self._write_text_to_file(text_content, target_path)
+
+            # 记录文件变更（如果需要）
+            if self.agent:
+                self.agent.record_file_change(
+                    file_path=target_path,
+                    change_type="added",
+                    content=text_content
+                )
+
+            # 统计信息
+            line_count = len(text_content.split('\n'))
+            char_count = len(text_content)
+            
+            success_message = f"Successfully extracted text from '{source_path}' to '{target_path}'"
+            if self._is_url(source_path):
+                success_message += f" (downloaded from URL)"
+            success_message += f" - {line_count} lines, {char_count} characters"
+
+            return ToolResult(
+                success=True,
+                message=success_message,
+                content={
+                    "source_path": source_path,
+                    "target_path": target_path,
+                    "line_count": line_count,
+                    "char_count": char_count,
+                    "is_url": self._is_url(source_path)
+                }
+            )
+
+        except Exception as e:
+            logger.error(f"ExtractToTextTool execution failed: {str(e)}")
+            return ToolResult(
+                success=False,
+                message=f"文本提取失败: {str(e)}"
+            )
+        
+        finally:
+            # 清理临时文件
+            if temp_file_path:
+                self._cleanup_temp_file(temp_file_path)

autocoder/common/v2/agent/agentic_edit_tools/lint_report.py

@@ -0,0 +1,79 @@
+"""
+Lint report data structure for AgenticEdit tools integration.
+"""
+
+from dataclasses import dataclass
+from typing import Dict, List, Any, Optional
+from autocoder.common.linter_core.models.lint_result import LintResult
+from autocoder.common.linter_core.linter_manager import LinterManager
+
+
+@dataclass
+class LintReport:
+    """Lint 检查报告 - 基于 linter_core 的简化实现"""
+    results: Dict[str, LintResult]  # 原始检查结果
+    summary: Dict[str, Any]         # LinterManager.get_summary_report() 的结果
+    
+    @classmethod
+    def from_linter_results(cls, results: Dict[str, LintResult], 
+                          manager: LinterManager) -> 'LintReport':
+        """从 LinterManager 的结果创建报告"""
+        summary = manager.get_summary_report(results)
+        return cls(results=results, summary=summary)
+    
+    def to_markdown(self) -> str:
+        """生成 Markdown 格式报告"""
+        lines = ["## Lint Report\n"]
+        
+        # 汇总信息
+        lines.append("### Summary")
+        lines.append(f"- Total files: {self.summary['total_files']}")
+        lines.append(f"- Files with issues: {self.summary['files_with_issues']}")
+        lines.append(f"- Failed files: {self.summary['failed_files']}")
+        lines.append(f"- Execution time: {self.summary['total_execution_time']:.2f}s\n")
+        
+        # 详细结果
+        if self.has_issues():
+            lines.append("### Issues Found")
+            for file_path, result in self.results.items():
+                if result.has_issues:
+                    lines.append(f"#### {file_path}")
+                    lines.append("```")
+                    lines.append(result.lint_output)
+                    lines.append("```\n")
+        
+        return "\n".join(lines)
+    
+    def to_simple_text(self) -> str:
+        """生成简单文本格式报告"""
+        if not self.has_issues():
+            return f"✅ Lint check passed - No issues found in {self.summary['total_files']} file(s)"
+        
+        lines = [f"❌ Lint issues detected in {self.summary['files_with_issues']} of {self.summary['total_files']} file(s):"]
+        for file_path, result in self.results.items():
+            if result.has_issues:
+                lines.append(f"\n{file_path}:")
+                lines.append(result.lint_output)
+        
+        return "\n".join(lines)
+    
+    def to_json(self) -> dict:
+        """生成 JSON 格式报告"""
+        return {
+            'summary': self.summary,
+            'results': {
+                path: result.to_dict() 
+                for path, result in self.results.items()
+            }
+        }
+    
+    def has_issues(self) -> bool:
+        """检查是否有任何问题"""
+        return self.summary.get('files_with_issues', 0) > 0
+    
+    def get_files_with_issues(self) -> List[str]:
+        """获取有问题的文件列表"""
+        return [
+            path for path, result in self.results.items() 
+            if result.has_issues
+        ]

autocoder/common/v2/agent/agentic_edit_tools/linter_config_models.py

@@ -0,0 +1,343 @@
+"""
+Pydantic models for linter configuration with type validation and defaults.
+"""
+
+from typing import List, Optional, Dict, Any, Literal
+from pydantic import BaseModel, Field, validator
+from pathlib import Path
+
+
+class FilePatterns(BaseModel):
+    """File pattern configuration for include/exclude rules."""
+    
+    include: List[str] = Field(
+        default=["*.py", "*.ts", "*.tsx", "*.js", "*.jsx", "*.java"],
+        description="List of glob patterns for files to include in linting"
+    )
+    exclude: List[str] = Field(
+        default=["*.test.*", "*.spec.*", "__pycache__", "node_modules", ".git"],
+        description="List of glob patterns for files to exclude from linting"
+    )
+    
+    @validator('include', 'exclude', pre=True)
+    def ensure_list(cls, v):
+        """Ensure the value is a list."""
+        if isinstance(v, str):
+            return [v]
+        return v
+
+
+class PythonConfig(BaseModel):
+    """Python-specific linter configuration."""
+    
+    use_mypy: bool = Field(
+        default=True,
+        description="Enable mypy type checking"
+    )
+    flake8_args: List[str] = Field(
+        default_factory=list,
+        description="Additional arguments for flake8"
+    )
+    mypy_args: List[str] = Field(
+        default_factory=list,
+        description="Additional arguments for mypy"
+    )
+    flake8_timeout: int = Field(
+        default=30,
+        ge=1,
+        le=300,
+        description="Timeout for flake8 execution in seconds"
+    )
+    mypy_timeout: int = Field(
+        default=30,
+        ge=1,
+        le=300,
+        description="Timeout for mypy execution in seconds"
+    )
+
+
+class TypeScriptConfig(BaseModel):
+    """TypeScript-specific linter configuration."""
+    
+    use_eslint: bool = Field(
+        default=True,
+        description="Enable ESLint checking"
+    )
+    tsc_args: List[str] = Field(
+        default=["--noEmit", "--strict"],
+        description="Arguments for TypeScript compiler"
+    )
+    eslint_args: List[str] = Field(
+        default_factory=list,
+        description="Additional arguments for ESLint"
+    )
+    tsconfig_path: Optional[str] = Field(
+        default=None,
+        description="Path to tsconfig.json file"
+    )
+    tsc_timeout: int = Field(
+        default=60,
+        ge=1,
+        le=300,
+        description="Timeout for tsc execution in seconds"
+    )
+    eslint_timeout: int = Field(
+        default=30,
+        ge=1,
+        le=300,
+        description="Timeout for ESLint execution in seconds"
+    )
+    
+    @validator('tsconfig_path')
+    def validate_tsconfig_path(cls, v):
+        """Validate tsconfig path if provided."""
+        if v and not Path(v).exists():
+            # Don't fail, just log warning (file might be created later)
+            pass
+        return v
+
+
+class JavaConfig(BaseModel):
+    """Java-specific linter configuration."""
+    
+    javac_args: List[str] = Field(
+        default_factory=list,
+        description="Additional arguments for javac"
+    )
+    javac_timeout: int = Field(
+        default=30,
+        ge=1,
+        le=300,
+        description="Timeout for javac execution in seconds"
+    )
+    project_type: Literal["auto", "maven", "gradle", "local"] = Field(
+        default="auto",
+        description="Project type for dependency resolution"
+    )
+    source_paths: List[str] = Field(
+        default=["src", "src/main/java"],
+        description="Source directories to search"
+    )
+    lib_dirs: List[str] = Field(
+        default=["lib", "libs"],
+        description="Directories containing JAR files"
+    )
+    enable_dependency_resolution: bool = Field(
+        default=True,
+        description="Enable automatic dependency resolution"
+    )
+    cache_dependencies: bool = Field(
+        default=True,
+        description="Cache resolved classpaths for performance"
+    )
+    release: str = Field(
+        default="8",
+        description="Java release version"
+    )
+    use_release_flag: bool = Field(
+        default=True,
+        description="Use --release flag (can be disabled for older javac)"
+    )
+
+
+class LanguageConfig(BaseModel):
+    """Container for all language-specific configurations."""
+    
+    python: PythonConfig = Field(
+        default_factory=PythonConfig,
+        description="Python linter configuration"
+    )
+    typescript: TypeScriptConfig = Field(
+        default_factory=TypeScriptConfig,
+        description="TypeScript linter configuration"
+    )
+    java: JavaConfig = Field(
+        default_factory=JavaConfig,
+        description="Java linter configuration"
+    )
+    
+    class Config:
+        extra = "allow"  # Allow additional language configurations
+
+
+class ReportConfig(BaseModel):
+    """Linter report configuration."""
+    
+    format: Literal["simple", "detailed", "json"] = Field(
+        default="simple",
+        description="Report format"
+    )
+    include_in_result: bool = Field(
+        default=True,
+        description="Include lint report in ToolResult content"
+    )
+    save_to_file: bool = Field(
+        default=False,
+        description="Save lint reports to files"
+    )
+    file_path: str = Field(
+        default=".auto-coder/lint-reports/",
+        description="Directory path for saving lint reports"
+    )
+    max_issues_shown: int = Field(
+        default=50,
+        ge=1,
+        le=1000,
+        description="Maximum number of issues to show in report"
+    )
+
+
+class LinterConfig(BaseModel):
+    """Main linter configuration model with type validation."""
+    
+    enabled: bool = Field(
+        default=False,
+        description="Global linter enable/disable switch"
+    )
+    mode: Literal["warning", "blocking", "silent"] = Field(
+        default="warning",
+        description="Linter operation mode"
+    )
+    check_before_modification: bool = Field(
+        default=False,
+        description="Run linter before applying modifications"
+    )
+    check_after_modification: bool = Field(
+        default=True,
+        description="Run linter after applying modifications"
+    )
+    max_workers: int = Field(
+        default=4,
+        ge=1,
+        le=32,
+        description="Maximum parallel workers for linting"
+    )
+    timeout: int = Field(
+        default=300,
+        ge=10,
+        le=3600,
+        description="Global timeout for linting operations in seconds"
+    )
+    file_patterns: FilePatterns = Field(
+        default_factory=FilePatterns,
+        description="File include/exclude patterns"
+    )
+    language_config: LanguageConfig = Field(
+        default_factory=LanguageConfig,
+        description="Language-specific configurations"
+    )
+    report: ReportConfig = Field(
+        default_factory=ReportConfig,
+        description="Report generation configuration"
+    )
+    
+    class Config:
+        """Pydantic configuration."""
+        validate_assignment = True
+        use_enum_values = True
+        extra = "forbid"  # Don't allow extra fields at root level
+        json_schema_extra = {
+            "example": {
+                "enabled": True,
+                "mode": "warning",
+                "check_after_modification": True,
+                "file_patterns": {
+                    "include": ["*.py", "*.ts"],
+                    "exclude": ["*.test.*"]
+                },
+                "language_config": {
+                    "python": {
+                        "use_mypy": True,
+                        "flake8_args": ["--max-line-length=120"]
+                    }
+                },
+                "report": {
+                    "format": "detailed",
+                    "include_in_result": True
+                }
+            }
+        }
+    
+    @validator('mode')
+    def validate_mode(cls, v):
+        """Validate linter mode."""
+        valid_modes = ["warning", "blocking", "silent"]
+        if v not in valid_modes:
+            raise ValueError(f"Invalid mode: {v}. Must be one of {valid_modes}")
+        return v
+    
+    @classmethod
+    def from_dict(cls, config_dict: Dict[str, Any]) -> 'LinterConfig':
+        """
+        Create LinterConfig from a dictionary, handling nested 'linter' key.
+        
+        Args:
+            config_dict: Configuration dictionary
+            
+        Returns:
+            LinterConfig instance
+        """
+        # Handle both direct config and nested under 'linter' key
+        if 'linter' in config_dict:
+            config_data = config_dict['linter']
+        else:
+            config_data = config_dict
+        
+        # Handle legacy 'language_config' key mapping
+        if 'language_config' in config_data:
+            lang_config = config_data['language_config']
+            
+            # Map old config structure to new structure
+            if 'python_config' in lang_config:
+                lang_config['python'] = lang_config.pop('python_config')
+            if 'typescript_config' in lang_config:
+                lang_config['typescript'] = lang_config.pop('typescript_config')
+            if 'java_config' in lang_config:
+                lang_config['java'] = lang_config.pop('java_config')
+        
+        return cls(**config_data)
+    
+    def to_manager_config(self) -> Dict[str, Any]:
+        """
+        Convert to LinterManager compatible configuration.
+        
+        Returns:
+            Dictionary suitable for LinterManager initialization
+        """
+        manager_config = {
+            'max_workers': self.max_workers,
+            'timeout': self.timeout,
+            'python_config': self.language_config.python.dict(),
+            'typescript_config': self.language_config.typescript.dict(),
+            'java_config': self.language_config.java.dict()
+        }
+        
+        return manager_config
+    
+    def should_lint_file(self, file_path: str) -> bool:
+        """
+        Check if a file should be linted based on patterns.
+        
+        Args:
+            file_path: Path to the file
+            
+        Returns:
+            True if file should be linted
+        """
+        if not self.enabled:
+            return False
+        
+        from pathlib import Path
+        path = Path(file_path)
+        
+        # Check exclude patterns first
+        for pattern in self.file_patterns.exclude:
+            if path.match(pattern):
+                return False
+        
+        # Check include patterns
+        for pattern in self.file_patterns.include:
+            if pattern == '*' or path.match(pattern):
+                return True
+        
+        return False