jarvis-ai-assistant 0.3.30__py3-none-any.whl → 0.7.0__py3-none-any.whl

jarvis/jarvis_code_agent/lint.py

@@ -3,10 +3,12 @@
 
 """
 Lint工具配置模块
+
+提供lint工具配置和命令生成功能。
 """
 
 import os
-from typing import Dict, List
+from typing import Dict, List, Tuple, Optional
 
 import yaml  # type: ignore
 
@@ -33,8 +35,8 @@ LINT_TOOLS = {
     ".pyx": ["ruff", "mypy"],
     ".pxd": ["ruff", "mypy"],
     # Rust
-    ".rs": ["cargo clippy", "rustfmt"],
-    ".rlib": ["cargo clippy", "rustfmt"],
+    ".rs": ["cargo clippy"],
+    ".rlib": ["cargo clippy"],
     # Java
     ".java": ["pmd"],
     ".class": ["pmd"],
@@ -113,8 +115,6 @@ LINT_TOOLS = {
     ".editorconfig": ["editorconfig-checker"],
     ".eslintrc": ["eslint"],
     ".prettierrc": ["prettier"],
-    "cmakelists.txt": ["cmake-format"],
-    ".cmake": ["cmake-format"],
 }
 
 
@@ -136,16 +136,278 @@ LINT_TOOLS.update(load_lint_tools_config())
 def get_lint_tools(filename: str) -> List[str]:
     """
     根据文件扩展名或文件名获取对应的lint工具列表
+    优先级：完整文件名匹配 > 扩展名匹配
 
     Args:
-        file_extension_or_name: 文件扩展名(如'.py')或文件名(如'Makefile')
+        filename: 文件路径或文件名(如'test.py'或'Makefile')
 
     Returns:
         对应的lint工具列表，如果找不到则返回空列表
     """
     filename = os.path.basename(filename)
-    lint_tools = LINT_TOOLS.get(filename.lower(), [])
+    filename_lower = filename.lower()
+    
+    # 优先尝试完整文件名匹配（例如 docker-compose.yml, .eslintrc, .prettierrc）
+    lint_tools = LINT_TOOLS.get(filename_lower, [])
     if lint_tools:
         return lint_tools
+    
+    # 如果文件名匹配失败，再尝试扩展名匹配
     ext = os.path.splitext(filename)[1]
-    return LINT_TOOLS.get(ext.lower(), [])
+    if ext:
+        return LINT_TOOLS.get(ext.lower(), [])
+    
+    return []
+
+
+# Lint工具命令模板映射
+# 占位符说明：
+# - {file_path}: 单个文件的完整路径
+# - {files}: 多个文件路径，用空格分隔
+# - {file_name}: 文件名（不含路径）
+LINT_COMMAND_TEMPLATES: Dict[str, str] = {
+    # Python
+    "ruff": "ruff check {file_path}",
+    "mypy": "mypy {file_path}",
+    "pylint": "pylint {file_path}",
+    "flake8": "flake8 {file_path}",
+    # JavaScript/TypeScript
+    "eslint": "eslint {file_path}",
+    "tsc": "tsc --noEmit {file_path}",
+    # Rust
+    "cargo clippy": "cargo clippy --message-format=short",
+    # Go
+    "go vet": "go vet {file_path}",
+    "golint": "golint {file_path}",
+    # Java
+    "pmd": "pmd check -d {file_path}",
+    "checkstyle": "checkstyle -c {config} {file_path}",
+    # C/C++
+    "clang-tidy": "clang-tidy {file_path}",
+    "cppcheck": "cppcheck {file_path}",
+    # PHP
+    "phpstan": "phpstan analyse {file_path}",
+    # Ruby
+    "rubocop": "rubocop {file_path}",
+    # Swift
+    "swiftlint": "swiftlint lint {file_path}",
+    # Kotlin
+    "ktlint": "ktlint {file_path}",
+    # C#
+    "roslynator": "roslynator analyze {file_path}",
+    # SQL
+    "sqlfluff": "sqlfluff lint {file_path}",
+    # Shell/Bash
+    "shellcheck": "shellcheck {file_path}",
+    # HTML/CSS
+    "htmlhint": "htmlhint {file_path}",
+    "stylelint": "stylelint {file_path}",
+    # XML/JSON/YAML
+    "xmllint": "xmllint --noout {file_path}",
+    "jsonlint": "jsonlint {file_path}",
+    "yamllint": "yamllint {file_path}",
+    # Markdown
+    "markdownlint": "markdownlint {file_path}",
+    "rstcheck": "rstcheck {file_path}",
+    # Docker
+    "hadolint": "hadolint {file_path}",
+    # Makefile
+    "checkmake": "checkmake {file_path}",
+}
+
+
+def find_config_file(config_names: List[str], project_root: Optional[str] = None, file_path: Optional[str] = None) -> Optional[str]:
+    """
+    查找配置文件
+    
+    Args:
+        config_names: 配置文件名列表（按优先级排序）
+        project_root: 项目根目录
+        file_path: 当前文件路径（可选，用于从文件所在目录向上查找）
+    
+    Returns:
+        配置文件的绝对路径，如果未找到则返回None
+    """
+    search_dirs = []
+    
+    if project_root:
+        search_dirs.append(project_root)
+    
+    # 如果提供了文件路径，从文件所在目录向上查找
+    if file_path:
+        if os.path.isabs(file_path):
+            current_dir = os.path.dirname(file_path)
+        elif project_root:
+            current_dir = os.path.dirname(os.path.join(project_root, file_path))
+        else:
+            current_dir = os.path.dirname(os.path.abspath(file_path))
+        
+        # 向上查找直到项目根目录
+        while current_dir:
+            if current_dir not in search_dirs:
+                search_dirs.append(current_dir)
+            if project_root and current_dir == project_root:
+                break
+            parent = os.path.dirname(current_dir)
+            if parent == current_dir:  # 到达根目录
+                break
+            current_dir = parent
+    
+    # 按优先级查找配置文件
+    for config_name in config_names:
+        for search_dir in search_dirs:
+            config_path = os.path.join(search_dir, config_name)
+            if os.path.exists(config_path) and os.path.isfile(config_path):
+                return os.path.abspath(config_path)
+    
+    return None
+
+
+# 工具配置文件映射（工具名 -> 可能的配置文件名列表）
+TOOL_CONFIG_FILES: Dict[str, List[str]] = {
+    "checkstyle": ["checkstyle.xml", ".checkstyle.xml", "checkstyle-config.xml"],
+    "eslint": [".eslintrc.js", ".eslintrc.json", ".eslintrc.yml", ".eslintrc.yaml", ".eslintrc"],
+    "stylelint": [".stylelintrc", ".stylelintrc.json", ".stylelintrc.yml", ".stylelintrc.yaml", "stylelint.config.js"],
+    "yamllint": [".yamllint", ".yamllint.yml", ".yamllint.yaml"],
+    "markdownlint": [".markdownlint.json", ".markdownlintrc"],
+    "rubocop": [".rubocop.yml", ".rubocop.yaml", ".rubocop.toml"],
+    "phpstan": ["phpstan.neon", "phpstan.neon.dist"],
+    "sqlfluff": [".sqlfluff", "sqlfluff.ini", ".sqlfluff.ini"],
+    "hadolint": [".hadolint.yaml", ".hadolint.yml"],
+}
+
+# 必须配置文件的工具（未找到配置文件时不能执行）
+REQUIRED_CONFIG_TOOLS = {"checkstyle"}
+
+# 可选配置文件的工具（未找到配置文件时可以使用默认配置）
+OPTIONAL_CONFIG_TOOLS = {"eslint", "stylelint", "yamllint", "markdownlint", "rubocop", "phpstan", "sqlfluff", "hadolint"}
+
+
+def get_lint_command(tool_name: str, file_path: str, project_root: Optional[str] = None) -> Optional[str]:
+    """
+    获取lint工具的具体命令
+
+    Args:
+        tool_name: lint工具名称（如 'ruff', 'eslint'）
+        file_path: 文件路径（相对或绝对路径）
+        project_root: 项目根目录（可选，用于处理相对路径）
+
+    Returns:
+        命令字符串，如果工具不支持则返回None
+    """
+    template = LINT_COMMAND_TEMPLATES.get(tool_name)
+    if not template:
+        return None
+    
+    # 特殊处理：某些工具不需要文件路径（如 cargo clippy）
+    if "{file_path}" not in template and "{file_name}" not in template:
+        # 不需要文件路径，直接返回模板
+        return template
+    
+    # 如果是绝对路径，直接使用；否则转换为绝对路径
+    if os.path.isabs(file_path):
+        abs_file_path = file_path
+    elif project_root:
+        abs_file_path = os.path.join(project_root, file_path)
+    else:
+        abs_file_path = os.path.abspath(file_path)
+    
+    # 准备占位符替换字典
+    placeholders = {
+        "file_path": abs_file_path,
+        "file_name": os.path.basename(abs_file_path),
+    }
+    
+    # 如果模板需要配置文件，尝试查找
+    if "{config}" in template:
+        config_names = TOOL_CONFIG_FILES.get(tool_name, [])
+        if config_names:
+            config_path = find_config_file(config_names, project_root, file_path)
+            if config_path:
+                placeholders["config"] = config_path
+            else:
+                # 未找到配置文件
+                if tool_name in REQUIRED_CONFIG_TOOLS:
+                    # 必须配置的工具，未找到配置文件则返回None
+                    return None
+                elif tool_name in OPTIONAL_CONFIG_TOOLS:
+                    # 可选配置的工具，使用默认配置（移除config参数或使用默认值）
+                    # 这里我们移除 {config} 占位符，让工具使用默认配置
+                    # 但需要修改模板，所以这里我们返回None，让调用方知道需要处理
+                    # 实际上，对于可选配置的工具，模板中不应该使用 {config}，或者应该提供默认值
+                    # 为了简化，我们这里返回None，表示无法生成命令
+                    # 更好的做法是在模板中提供默认值，如: "checkstyle {file_path}" 或 "checkstyle -c default.xml {file_path}"
+                    return None
+                else:
+                    # 未定义的工具，返回None
+                    return None
+        else:
+            # 工具需要配置但未定义配置文件名，返回None
+            return None
+    
+    # 替换占位符
+    try:
+        command = template.format(**placeholders)
+    except KeyError:
+        # 如果模板中有未定义的占位符，返回None
+        return None
+    
+    return command
+
+
+def get_lint_commands_for_files(
+    files: List[str], 
+    project_root: Optional[str] = None
+) -> List[Tuple[str, str, str]]:
+    """
+    获取多个文件的lint命令列表
+
+    Args:
+        files: 文件路径列表
+        project_root: 项目根目录（可选）
+
+    Returns:
+        [(tool_name, file_path, command), ...] 格式的命令列表
+    """
+    commands = []
+    # 记录不需要文件路径的工具（如 cargo clippy），避免重复执行
+    project_level_tools = set()
+    
+    for file_path in files:
+        tools = get_lint_tools(file_path)
+        for tool_name in tools:
+            # 检查是否是项目级别的工具（不需要文件路径）
+            template = LINT_COMMAND_TEMPLATES.get(tool_name)
+            if template and "{file_path}" not in template and "{file_name}" not in template:
+                # 项目级别工具，每个项目只执行一次
+                if tool_name not in project_level_tools:
+                    project_level_tools.add(tool_name)
+                    command = get_lint_command(tool_name, file_path, project_root)
+                    if command:
+                        # 使用第一个文件作为标识
+                        commands.append((tool_name, file_path, command))
+            else:
+                # 文件级别工具，每个文件都执行
+                command = get_lint_command(tool_name, file_path, project_root)
+                if command:
+                    commands.append((tool_name, file_path, command))
+    
+    return commands
+
+
+def group_commands_by_tool(commands: List[Tuple[str, str, str]]) -> Dict[str, List[Tuple[str, str]]]:
+    """
+    按工具分组命令
+
+    Args:
+        commands: [(tool_name, file_path, command), ...] 格式的命令列表
+
+    Returns:
+        {tool_name: [(file_path, command), ...]} 格式的字典
+    """
+    grouped = {}
+    for tool_name, file_path, command in commands:
+        if tool_name not in grouped:
+            grouped[tool_name] = []
+        grouped[tool_name].append((file_path, command))
+    return grouped

jarvis/jarvis_code_agent/utils.py

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+"""CodeAgent 工具函数模块。
+
+提供项目概况等工具函数。
+"""
+
+import os
+import subprocess
+from typing import List, Optional
+
+from jarvis.jarvis_utils.git_utils import get_recent_commits_with_files
+from jarvis.jarvis_utils.utils import get_loc_stats
+
+
+def get_git_tracked_files_info(project_root: str, max_files: int = 100) -> Optional[str]:
+    """获取git托管的文件列表或目录结构
+    
+    如果文件数量超过max_files，则返回目录结构（不含文件）
+    
+    参数:
+        project_root: 项目根目录
+        max_files: 文件数量阈值，超过此值则返回目录结构
+        
+    返回:
+        str: 文件列表或目录结构的字符串表示，失败时返回None
+    """
+    try:
+        # 获取所有git托管的文件
+        result = subprocess.run(
+            ["git", "ls-files"],
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=True,
+            cwd=project_root,
+        )
+        
+        if result.returncode != 0 or not result.stdout.strip():
+            return None
+        
+        files = [line.strip() for line in result.stdout.strip().splitlines() if line.strip()]
+        file_count = len(files)
+        
+        if file_count == 0:
+            return None
+        
+        # 如果文件数量超过阈值，返回目录结构
+        if file_count > max_files:
+            # 提取所有目录路径
+            dirs = set()
+            for file_path in files:
+                # 获取文件所在的所有父目录
+                parts = file_path.split("/")
+                for i in range(1, len(parts)):
+                    dir_path = "/".join(parts[:i])
+                    if dir_path:
+                        dirs.add(dir_path)
+            
+            # 构建树形目录结构
+            dir_tree = {}
+            for dir_path in sorted(dirs):
+                parts = dir_path.split("/")
+                current = dir_tree
+                for part in parts:
+                    if part not in current:
+                        current[part] = {}
+                    current = current[part]
+            
+            def format_tree(tree: dict, prefix: str = "", is_last: bool = True) -> List[str]:
+                """格式化目录树"""
+                lines = []
+                items = sorted(tree.items())
+                for i, (name, subtree) in enumerate(items):
+                    is_last_item = i == len(items) - 1
+                    connector = "└── " if is_last_item else "├── "
+                    lines.append(f"{prefix}{connector}{name}/")
+                    
+                    extension = "    " if is_last_item else "│   "
+                    if subtree:
+                        lines.extend(format_tree(subtree, prefix + extension, is_last_item))
+                return lines
+            
+            tree_lines = format_tree(dir_tree)
+            return f"Git托管目录结构（共{file_count}个文件）:\n" + "\n".join(tree_lines)
+        else:
+            # 文件数量不多，直接返回文件列表
+            files_str = "\n".join(f"  - {file}" for file in sorted(files))
+            return f"Git托管文件列表（共{file_count}个文件）:\n{files_str}"
+            
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+    except Exception:
+        # 其他异常，静默失败
+        return None
+
+
+def get_project_overview(project_root: str) -> str:
+    """获取项目概况信息
+    
+    参数:
+        project_root: 项目根目录
+        
+    返回:
+        项目概况字符串
+    """
+    project_info = []
+    
+    # 获取代码统计
+    try:
+        loc_stats = get_loc_stats()
+        if loc_stats:
+            project_info.append(f"代码统计:\n{loc_stats}")
+    except Exception:
+        pass
+    
+    # 获取Git托管的文件信息
+    try:
+        git_files_info = get_git_tracked_files_info(project_root)
+        if git_files_info:
+            project_info.append(git_files_info)
+    except Exception:
+        pass
+    
+    # 获取最近提交信息
+    try:
+        commits_info = get_recent_commits_with_files()
+        if commits_info:
+            commits_str = "\n".join(
+                f"提交 {i+1}: {commit['hash'][:7]} - {commit['message']} ({len(commit['files'])}个文件)\n"
+                + "\n".join(f"    - {file}" for file in commit["files"][:5])
+                + ("\n    ..." if len(commit["files"]) > 5 else "")
+                for i, commit in enumerate(commits_info[:5])
+            )
+            project_info.append(f"最近提交:\n{commits_str}")
+    except Exception:
+        pass
+    
+    if project_info:
+        return "项目概况:\n" + "\n\n".join(project_info)
+    return ""
+