jarvis-ai-assistant 0.7.16__py3-none-any.whl → 1.0.2__py3-none-any.whl

jarvis/jarvis_code_agent/code_agent_postprocess.py

@@ -0,0 +1,105 @@
+"""CodeAgent 后处理模块"""
+
+import os
+import subprocess
+
+from jarvis.jarvis_utils.output import PrettyOutput
+
+# -*- coding: utf-8 -*-
+from typing import List
+
+from jarvis.jarvis_code_agent.after_change import get_after_change_commands_for_files
+
+
+class PostProcessManager:
+    """后处理管理器"""
+
+    def __init__(self, root_dir: str):
+        self.root_dir = root_dir
+
+    def post_process_modified_files(self, modified_files: List[str]) -> None:
+        """文件后处理（包括格式化、自动修复等）
+
+        Args:
+            modified_files: 修改的文件列表
+        """
+        # 获取变更后处理命令
+        after_change_commands = get_after_change_commands_for_files(
+            modified_files, self.root_dir
+        )
+        if not after_change_commands:
+            return
+
+        # 执行变更后处理命令
+        processed_files = set()
+        for file_path, command in after_change_commands:
+            # 从命令中提取工具名（第一个单词）用于日志
+            tool_name = command.split()[0] if command.split() else "unknown"
+            try:
+                # 检查文件是否存在
+                abs_file_path = (
+                    os.path.join(self.root_dir, file_path)
+                    if not os.path.isabs(file_path)
+                    else file_path
+                )
+                if not os.path.exists(abs_file_path):
+                    continue
+
+                # 执行变更后处理命令
+                result = subprocess.run(
+                    command,
+                    shell=True,
+                    cwd=self.root_dir,
+                    capture_output=True,
+                    text=True,
+                    encoding="utf-8",
+                    errors="replace",
+                    timeout=300,  # 300秒超时
+                )
+
+                if result.returncode == 0:
+                    processed_files.add(file_path)
+                    PrettyOutput.auto_print(
+                        f"✅ 已处理: {os.path.basename(file_path)} ({tool_name})"
+                    )
+                else:
+                    # 处理失败，记录但不中断流程
+                    error_msg = (result.stderr or result.stdout or "").strip()
+                    if error_msg:
+                        PrettyOutput.auto_print(
+                            f"⚠️ 处理失败 ({os.path.basename(file_path)}, {tool_name}): {error_msg[:200]}"
+                        )
+            except subprocess.TimeoutExpired:
+                PrettyOutput.auto_print(
+                    f"⚠️ 处理超时: {os.path.basename(file_path)} ({tool_name})"
+                )
+            except FileNotFoundError:
+                # 工具未安装，跳过
+                continue
+            except Exception as e:
+                # 其他错误，记录但继续
+                PrettyOutput.auto_print(
+                    f"⚠️ 处理失败 ({os.path.basename(file_path)}, {tool_name}): {str(e)[:100]}"
+                )
+                continue
+
+        if processed_files:
+            PrettyOutput.auto_print(f"✅ 已处理 {len(processed_files)} 个文件")
+            # 暂存处理后的文件
+            try:
+                for file_path in processed_files:
+                    abs_file_path = (
+                        os.path.join(self.root_dir, file_path)
+                        if not os.path.isabs(file_path)
+                        else file_path
+                    )
+                    if os.path.exists(abs_file_path):
+                        subprocess.run(
+                            ["git", "add", file_path],
+                            cwd=self.root_dir,
+                            check=False,
+                            stdout=subprocess.DEVNULL,
+                            stderr=subprocess.DEVNULL,
+                        )
+            except Exception:
+                pass

jarvis/jarvis_code_agent/code_agent_prompts.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+"""CodeAgent 系统提示词模块"""
+
+
+def get_system_prompt() -> str:
+    """获取代码工程师的系统提示词"""
+    return """
+你是Jarvis代码工程师，专注于**项目级代码分析、精准修改与问题排查**，核心原则：自主决策、高效精准、可回退、工具优先、禁止臆测。
+
+## 元指令
+- 每次响应开头必须声明模式，格式`[MODE: MODE_NAME]`；默认 INTENT。
+- 模式切换信号：ENTER INTENT/RESEARCH/INNOVATE/PLAN/EXECUTE/REVIEW。
+- 简单任务直接执行；复杂任务才用 task_list_manager，避免过度拆分。
+ - **整体工作流必须严格按照 IIRIPER 流程顺序执行：INTENT → RESEARCH → INNOVATE → PLAN → EXECUTE → REVIEW。禁止跳过任意阶段或乱序进入后续模式，除非用户以非常明确的指令要求跳过，并且需要在回复中显式说明原因。**
+
+## 模式速览（IIRIPER）
+- **INTENT**：澄清需求与约束，提炼目标与疑点，先问清楚再动手。
+- **RESEARCH**：只读不改，定位文件/上下文/约束，不给方案。
+- **INNOVATE**：头脑风暴多种方案，评估优劣，不写实现。
+- **PLAN**：给出可执行技术方案，必要时用 task_list_manager 创建任务列表并切分大数据/多目录；禁止编写代码。
+- **EXECUTE**：按计划实施；每次 `execute_task` 必须带非空 `additional_info`（背景+关键信息+约束+预期结果）；已有任务列表时优先用 task_list_manager。单次回复只做一个工具调用（完成时除外）。
+- **REVIEW**：核对完成度与影响面，必要时用 task_list_manager 获取任务状态。
+
+### IIRIPER 严格执行要求
+- 任何任务都应从 **INTENT** 开始，对需求/约束对齐后，依次进入 **RESEARCH → INNOVATE → PLAN → EXECUTE → REVIEW**。
+- **禁止**在未经过 PLAN 就直接进入 EXECUTE，更禁止从 INTENT 直接跳到 EXECUTE/REVIEW。
+- 如因用户强制要求跳过某阶段，必须在当前回复中说明“跳过了哪个阶段、为什么合理、可能的风险”，并尽量补充最小必要分析。
+
+## 关键流程（闭环）
+1) 对齐需求与约束；锁定核心目录/技术栈/风格。
+2) 精准定位文件（搜索需带目录/后缀过滤；能不用就不盲读）。
+3) 读取并分析上下文，禁止凭空猜测。
+4) 设计最小可回退改动，先备份核心改动再动手。
+5) 先读后写：用 read_code 确认位置，再用 edit_file 精准修改；避免 sed/脚本处理复杂改动。
+6) 验证：语法/构建/关键路径/必要用例；清理临时文件与日志。
+
+## 工具与质量
+- 搜索：必须过滤目录/后缀；只查相关代码。
+- read_code：只读目标及直接相关依赖，避免日志/数据/依赖包。
+- edit_file：保持原缩进与风格，不留多余空行。
+- 质量底线：语法正确；不破坏已有功能；风格一致；改动可维护且必要处可加简短注释。
+
+## 禁止项
+- 虚构代码/路径/依赖；无差别大范围读取；大删大改未授权；改非项目目录；复杂改动用 sed/python；提交临时文件。
+
+"""

jarvis/jarvis_code_agent/code_agent_rules.py

@@ -0,0 +1,305 @@
+"""CodeAgent 规则管理模块"""
+
+import os
+import subprocess
+
+from jarvis.jarvis_utils.output import PrettyOutput
+
+# -*- coding: utf-8 -*-
+from typing import List
+from typing import Optional
+
+import yaml
+
+from jarvis.jarvis_code_agent.builtin_rules import get_builtin_rule
+from jarvis.jarvis_utils.config import get_central_rules_repo
+from jarvis.jarvis_utils.config import get_data_dir
+from jarvis.jarvis_utils.config import get_rules_load_dirs
+from jarvis.jarvis_utils.utils import daily_check_git_updates
+
+
+class RulesManager:
+    """规则管理器，负责加载和管理各种规则"""
+
+    def __init__(self, root_dir: str):
+        self.root_dir = root_dir
+        # 初始化规则目录列表
+        self._init_rules_dirs()
+
+    def _init_rules_dirs(self) -> None:
+        """初始化规则目录列表，包括配置的目录和中心库"""
+        # 基础目录：全局数据目录下的 rules 目录
+        self.rules_dirs: List[str] = [os.path.join(get_data_dir(), "rules")]
+
+        # 添加配置的规则加载目录
+        self.rules_dirs.extend(get_rules_load_dirs())
+
+        # 中心规则仓库路径（单独存储，优先级最高）
+        self.central_repo_path: Optional[str] = None
+        central_repo = get_central_rules_repo()
+        if central_repo:
+            # 支持本地目录路径或Git仓库URL
+            expanded = os.path.expanduser(os.path.expandvars(central_repo))
+            if os.path.isdir(expanded):
+                # 直接使用本地目录（支持Git仓库的子目录）
+                self.central_repo_path = expanded
+            else:
+                # 中心规则仓库存储在数据目录下的特定位置
+                self.central_repo_path = os.path.join(
+                    get_data_dir(), "central_rules_repo"
+                )
+
+                # 确保中心规则仓库被克隆/更新
+                if not os.path.exists(self.central_repo_path):
+                    try:
+                        PrettyOutput.auto_print(
+                            f"ℹ️ 正在克隆中心规则仓库: {central_repo}"
+                        )
+                        subprocess.run(
+                            ["git", "clone", central_repo, self.central_repo_path],
+                            check=True,
+                        )
+                    except Exception as e:
+                        PrettyOutput.auto_print(f"❌ 克隆中心规则仓库失败: {str(e)}")
+
+        # 执行每日更新检查（包括中心库）
+        all_dirs_for_update = self.rules_dirs.copy()
+        if self.central_repo_path:
+            all_dirs_for_update.append(self.central_repo_path)
+        daily_check_git_updates(all_dirs_for_update, "rules")
+
+    def read_project_rule(self) -> Optional[str]:
+        """读取 .jarvis/rule 文件内容，如果存在则返回字符串，否则返回 None"""
+        try:
+            rules_path = os.path.join(self.root_dir, ".jarvis", "rule")
+            if os.path.exists(rules_path) and os.path.isfile(rules_path):
+                with open(rules_path, "r", encoding="utf-8", errors="replace") as f:
+                    content = f.read().strip()
+                return content if content else None
+        except Exception:
+            # 读取规则失败时忽略，不影响主流程
+            pass
+        return None
+
+    def read_global_rules(self) -> Optional[str]:
+        """读取数据目录 rules 内容，如果存在则返回字符串，否则返回 None"""
+        try:
+            rules_path = os.path.join(get_data_dir(), "rule")
+            if os.path.exists(rules_path) and os.path.isfile(rules_path):
+                with open(rules_path, "r", encoding="utf-8", errors="replace") as f:
+                    content = f.read().strip()
+                return content if content else None
+        except Exception:
+            # 读取规则失败时忽略，不影响主流程
+            pass
+        return None
+
+    def _read_rule_from_dir(self, rules_dir: str, rule_name: str) -> Optional[str]:
+        """从 rules 目录中读取指定名称的规则文件
+
+        参数:
+            rules_dir: rules 目录路径
+            rule_name: 规则名称（文件名）
+
+        返回:
+            str: 规则内容，如果未找到则返回 None
+        """
+        try:
+            rule_file_path = os.path.join(rules_dir, rule_name)
+            if os.path.exists(rule_file_path) and os.path.isfile(rule_file_path):
+                with open(rule_file_path, "r", encoding="utf-8", errors="replace") as f:
+                    content = f.read().strip()
+                return content if content else None
+        except Exception:
+            # 读取规则失败时忽略，不影响主流程
+            pass
+        return None
+
+    def _get_all_rules_dirs(self) -> List[str]:
+        """获取所有规则目录（包括项目目录和配置的目录）
+
+        返回:
+            List[str]: 规则目录列表，按优先级排序（中心库 > 项目 > 配置目录）
+        """
+        all_dirs = []
+        # 优先级 1: 中心规则仓库（如果有同名规则，以中心仓库为准）
+        if (
+            self.central_repo_path
+            and os.path.exists(self.central_repo_path)
+            and os.path.isdir(self.central_repo_path)
+        ):
+            # 检查中心仓库中是否有 rules 子目录
+            central_rules_dir = os.path.join(self.central_repo_path, "rules")
+            if os.path.exists(central_rules_dir) and os.path.isdir(central_rules_dir):
+                all_dirs.append(central_rules_dir)
+            else:
+                # 如果没有 rules 子目录，直接使用中心仓库根目录
+                all_dirs.append(self.central_repo_path)
+        # 优先级 2: 项目 rules 目录
+        project_rules_dir = os.path.join(self.root_dir, ".jarvis", "rules")
+        if os.path.exists(project_rules_dir) and os.path.isdir(project_rules_dir):
+            all_dirs.append(project_rules_dir)
+        # 优先级 3-N: 配置的规则目录（不包括中心库）
+        all_dirs.extend(self.rules_dirs)
+        return all_dirs
+
+    def _get_all_rules_yaml_files(self) -> List[tuple[str, str]]:
+        """获取所有 rules.yaml 文件路径（描述，文件路径）
+
+        返回:
+            List[tuple[str, str]]: (描述, 文件路径) 列表，按优先级排序（中心库 > 项目 > 全局）
+        """
+        yaml_files = []
+        # 优先级 1: 中心规则仓库的 rules.yaml（如果有同名规则，以中心仓库为准）
+        if self.central_repo_path and os.path.exists(self.central_repo_path):
+            central_rules_yaml = os.path.join(self.central_repo_path, "rules.yaml")
+            if os.path.exists(central_rules_yaml) and os.path.isfile(
+                central_rules_yaml
+            ):
+                yaml_files.append(("中心库", central_rules_yaml))
+        # 优先级 2: 项目 rules.yaml
+        project_rules_yaml = os.path.join(self.root_dir, ".jarvis", "rules.yaml")
+        if os.path.exists(project_rules_yaml) and os.path.isfile(project_rules_yaml):
+            yaml_files.append(("项目", project_rules_yaml))
+        # 优先级 3: 全局 rules.yaml
+        global_rules_yaml = os.path.join(get_data_dir(), "rules.yaml")
+        if os.path.exists(global_rules_yaml) and os.path.isfile(global_rules_yaml):
+            yaml_files.append(("全局", global_rules_yaml))
+        return yaml_files
+
+    def get_named_rule(self, rule_name: str) -> Optional[str]:
+        """从 rules.yaml 文件和 rules 目录中获取指定名称的规则
+
+        查找优先级（从高到低）:
+        1. 中心规则仓库中的文件（如果有同名规则，以中心仓库为准）
+        2. 项目 rules 目录中的文件
+        3. 项目 rules.yaml 文件
+        4. 配置的规则目录中的文件（按配置顺序，不包括中心库）
+        5. 全局 rules.yaml 文件
+        6. 内置规则（最低优先级，作为后备）
+
+        参数:
+            rule_name: 规则名称
+
+        返回:
+            str: 规则内容，如果未找到则返回 None
+        """
+        try:
+            # 优先级 1: 从所有规则目录读取（中心库 > 项目 > 配置目录）
+            for rules_dir in self._get_all_rules_dirs():
+                if os.path.exists(rules_dir) and os.path.isdir(rules_dir):
+                    rule_content = self._read_rule_from_dir(rules_dir, rule_name)
+                    if rule_content:
+                        return rule_content
+
+            # 优先级 2: 从所有 rules.yaml 文件读取（中心库 > 项目 > 全局）
+            for desc, yaml_path in self._get_all_rules_yaml_files():
+                if os.path.exists(yaml_path) and os.path.isfile(yaml_path):
+                    try:
+                        with open(
+                            yaml_path, "r", encoding="utf-8", errors="replace"
+                        ) as f:
+                            rules = yaml.safe_load(f) or {}
+                        if rule_name in rules:
+                            rule_value = rules[rule_name]
+                            if isinstance(rule_value, str):
+                                content = rule_value.strip()
+                            else:
+                                content = str(rule_value).strip()
+                            if content:
+                                return content
+                    except Exception:
+                        # 单个文件读取失败不影响其他文件
+                        continue
+
+            # 优先级 3: 从内置规则中查找（最低优先级，作为后备）
+            builtin_rule = get_builtin_rule(rule_name)
+            if builtin_rule:
+                return builtin_rule
+
+            return None
+        except Exception as e:
+            # 读取规则失败时忽略，不影响主流程
+            PrettyOutput.auto_print(f"⚠️ 读取规则失败: {e}")
+            return None
+
+    def get_all_available_rule_names(self) -> dict[str, List[str]]:
+        """获取所有可用的规则名称，按来源分类
+
+        返回:
+            dict[str, List[str]]: 按来源分类的规则名称字典
+                - "builtin": 内置规则列表
+                - "files": 规则目录中的文件规则列表
+                - "yaml": rules.yaml 文件中的规则列表
+        """
+        from jarvis.jarvis_code_agent.builtin_rules import list_builtin_rules
+
+        result = {
+            "builtin": list_builtin_rules(),
+            "files": [],
+            "yaml": [],
+        }
+
+        # 收集规则目录中的文件规则
+        for rules_dir in self._get_all_rules_dirs():
+            if os.path.exists(rules_dir) and os.path.isdir(rules_dir):
+                try:
+                    for filename in os.listdir(rules_dir):
+                        file_path = os.path.join(rules_dir, filename)
+                        if os.path.isfile(file_path):
+                            # 规则名称就是文件名
+                            if filename not in result["files"]:
+                                result["files"].append(filename)
+                except Exception:
+                    continue
+
+        # 收集 rules.yaml 文件中的规则
+        for desc, yaml_path in self._get_all_rules_yaml_files():
+            if os.path.exists(yaml_path) and os.path.isfile(yaml_path):
+                try:
+                    with open(yaml_path, "r", encoding="utf-8", errors="replace") as f:
+                        rules = yaml.safe_load(f) or {}
+                        if isinstance(rules, dict):
+                            for rule_name in rules.keys():
+                                if rule_name not in result["yaml"]:
+                                    result["yaml"].append(rule_name)
+                except Exception:
+                    continue
+
+        return result
+
+    def load_all_rules(self, rule_names: Optional[str] = None) -> tuple[str, List[str]]:
+        """加载所有规则并合并
+
+        参数:
+            rule_names: 规则名称列表（逗号分隔）
+
+        返回:
+            (merged_rules, loaded_rule_names): 合并后的规则字符串和已加载的规则名称列表
+        """
+        combined_parts: List[str] = []
+        loaded_rule_names: List[str] = []
+
+        global_rules = self.read_global_rules()
+        project_rules = self.read_project_rule()
+
+        if global_rules:
+            combined_parts.append(global_rules)
+            loaded_rule_names.append("global_rule")
+        if project_rules:
+            combined_parts.append(project_rules)
+            loaded_rule_names.append("project_rule")
+
+        # 如果指定了 rule_names，从 rules.yaml 文件中读取并添加多个规则
+        if rule_names:
+            rule_list = [name.strip() for name in rule_names.split(",") if name.strip()]
+            for rule_name in rule_list:
+                named_rule = self.get_named_rule(rule_name)
+                if named_rule:
+                    combined_parts.append(named_rule)
+                    loaded_rule_names.append(rule_name)
+
+        if combined_parts:
+            merged_rules = "\n\n".join(combined_parts)
+            return merged_rules, loaded_rule_names
+        return "", []

jarvis/jarvis_code_agent/code_analyzer/__init__.py

@@ -3,63 +3,67 @@
 提供符号提取、依赖分析和上下文管理功能。
 """
 
-from .symbol_extractor import Symbol, SymbolTable, SymbolExtractor
-from .dependency_analyzer import Dependency, DependencyGraph, DependencyAnalyzer
-from .context_manager import ContextManager, EditContext, Reference
+from .base_language import BaseLanguageSupport
+from .context_manager import ContextManager
+from .context_manager import EditContext
+from .context_manager import Reference
 from .context_recommender import ContextRecommendation
+from .dependency_analyzer import Dependency
+from .dependency_analyzer import DependencyAnalyzer
+from .dependency_analyzer import DependencyGraph
+from .impact_analyzer import Edit
+from .impact_analyzer import Impact
+from .impact_analyzer import ImpactAnalyzer
+from .impact_analyzer import ImpactReport
+from .impact_analyzer import ImpactType
+from .impact_analyzer import InterfaceChange
+from .impact_analyzer import RiskLevel
+from .impact_analyzer import TestDiscoverer
+from .impact_analyzer import parse_git_diff_to_edits
+from .language_registry import LanguageRegistry
+from .language_registry import get_registry
+from .language_registry import register_language
+from .language_support import detect_language
+from .language_support import get_dependency_analyzer
+from .language_support import get_symbol_extractor
 from .llm_context_recommender import ContextRecommender
-from .language_support import detect_language, get_symbol_extractor, get_dependency_analyzer
-from .base_language import BaseLanguageSupport
-from .language_registry import LanguageRegistry, get_registry, register_language
-from .impact_analyzer import (
-    ImpactAnalyzer,
-    Impact,
-    ImpactReport,
-    ImpactType,
-    RiskLevel,
-    InterfaceChange,
-    Edit,
-    TestDiscoverer,
-    parse_git_diff_to_edits,
-)
-from .structured_code import StructuredCodeExtractor
+from .symbol_extractor import Symbol
+from .symbol_extractor import SymbolExtractor
+from .symbol_extractor import SymbolTable
 
 __all__ = [
     # Symbol extraction
-    'Symbol',
-    'SymbolTable',
-    'SymbolExtractor',
+    "Symbol",
+    "SymbolTable",
+    "SymbolExtractor",
     # Dependency analysis
-    'Dependency',
-    'DependencyGraph',
-    'DependencyAnalyzer',
+    "Dependency",
+    "DependencyGraph",
+    "DependencyAnalyzer",
     # Context management
-    'ContextManager',
-    'EditContext',
-    'Reference',
+    "ContextManager",
+    "EditContext",
+    "Reference",
     # Context recommendation
-    'ContextRecommender',
-    'ContextRecommendation',
+    "ContextRecommender",
+    "ContextRecommendation",
     # Language support
-    'detect_language',
-    'get_symbol_extractor',
-    'get_dependency_analyzer',
+    "detect_language",
+    "get_symbol_extractor",
+    "get_dependency_analyzer",
     # Language registry
-    'BaseLanguageSupport',
-    'LanguageRegistry',
-    'get_registry',
-    'register_language',
+    "BaseLanguageSupport",
+    "LanguageRegistry",
+    "get_registry",
+    "register_language",
     # Impact analysis
-    'ImpactAnalyzer',
-    'Impact',
-    'ImpactReport',
-    'ImpactType',
-    'RiskLevel',
-    'InterfaceChange',
-    'Edit',
-    'TestDiscoverer',
-    'parse_git_diff_to_edits',
-    # Structured code extraction
-    'StructuredCodeExtractor',
+    "ImpactAnalyzer",
+    "Impact",
+    "ImpactReport",
+    "ImpactType",
+    "RiskLevel",
+    "InterfaceChange",
+    "Edit",
+    "TestDiscoverer",
+    "parse_git_diff_to_edits",
 ]
-

jarvis/jarvis_code_agent/code_analyzer/base_language.py

@@ -3,8 +3,10 @@
 定义所有语言支持需要实现的接口，便于扩展新的语言支持。
 """
 
-from abc import ABC, abstractmethod
-from typing import Optional, Set
+from abc import ABC
+from abc import abstractmethod
+from typing import Optional
+from typing import Set
 
 from .dependency_analyzer import DependencyAnalyzer
 from .symbol_extractor import SymbolExtractor
@@ -12,7 +14,7 @@ from .symbol_extractor import SymbolExtractor
 
 class BaseLanguageSupport(ABC):
     """语言支持的基础抽象类。
-    
+
     所有语言支持类都应该继承此类并实现所需的方法。
     """
 
@@ -31,7 +33,7 @@ class BaseLanguageSupport(ABC):
     @abstractmethod
     def create_symbol_extractor(self) -> Optional[SymbolExtractor]:
         """创建并返回该语言的符号提取器实例。
-        
+
         Returns:
             SymbolExtractor实例，如果不支持符号提取则返回None
         """
@@ -40,7 +42,7 @@ class BaseLanguageSupport(ABC):
     @abstractmethod
     def create_dependency_analyzer(self) -> Optional[DependencyAnalyzer]:
         """创建并返回该语言的依赖分析器实例。
-        
+
         Returns:
             DependencyAnalyzer实例，如果不支持依赖分析则返回None
         """
@@ -48,27 +50,27 @@ class BaseLanguageSupport(ABC):
 
     def is_source_file(self, file_path: str) -> bool:
         """检查文件是否为该语言的源文件。
-        
+
         Args:
             file_path: 文件路径
-            
+
         Returns:
             如果是该语言的源文件返回True，否则返回False
         """
         import os
+
         _, ext = os.path.splitext(file_path)
         return ext in self.file_extensions
 
     def detect_language(self, file_path: str) -> Optional[str]:
         """检测文件是否属于该语言。
-        
+
         Args:
             file_path: 文件路径
-            
+
         Returns:
             如果属于该语言返回language_name，否则返回None
         """
         if self.is_source_file(file_path):
             return self.language_name
         return None
-

jarvis/jarvis_code_agent/code_analyzer/build_validator/__init__.py

@@ -8,20 +8,22 @@
 """
 
 # 导出主要接口
-from .base import BuildSystem, BuildResult, BuildValidatorBase
+from .base import BuildResult
+from .base import BuildSystem
+from .base import BuildValidatorBase
+from .cmake import CMakeBuildValidator
 from .detector import BuildSystemDetector
-from .validator import BuildValidator
+from .fallback import FallbackBuildValidator
+from .go import GoBuildValidator
+from .java_gradle import JavaGradleBuildValidator
+from .java_maven import JavaMavenBuildValidator
+from .makefile import MakefileBuildValidator
+from .nodejs import NodeJSBuildValidator
+from .python import PythonBuildValidator
 
 # 导出各语言验证器（便于扩展）
 from .rust import RustBuildValidator
-from .python import PythonBuildValidator
-from .nodejs import NodeJSBuildValidator
-from .java_maven import JavaMavenBuildValidator
-from .java_gradle import JavaGradleBuildValidator
-from .go import GoBuildValidator
-from .cmake import CMakeBuildValidator
-from .makefile import MakefileBuildValidator
-from .fallback import FallbackBuildValidator
+from .validator import BuildValidator
 
 __all__ = [
     # 主要接口
@@ -41,4 +43,3 @@ __all__ = [
     "MakefileBuildValidator",
     "FallbackBuildValidator",
 ]
-