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

jarvis/jarvis_code_agent/code_agent_impact.py

@@ -0,0 +1,177 @@
+"""CodeAgent 影响分析模块"""
+
+from typing import Any
+from typing import Dict
+
+from jarvis.jarvis_utils.output import PrettyOutput
+
+# -*- coding: utf-8 -*-
+from typing import List
+from typing import Optional
+from typing import Tuple
+
+from jarvis.jarvis_code_agent.code_analyzer import ContextManager
+from jarvis.jarvis_code_agent.code_analyzer import ImpactAnalyzer
+from jarvis.jarvis_code_agent.code_analyzer import parse_git_diff_to_edits
+from jarvis.jarvis_code_agent.code_analyzer.impact_analyzer import Edit
+from jarvis.jarvis_utils.config import is_enable_impact_analysis
+
+
+class ImpactManager:
+    """影响分析管理器"""
+
+    def __init__(self, root_dir: str, context_manager: ContextManager):
+        self.root_dir = root_dir
+        self.context_manager = context_manager
+
+    def update_context_for_modified_files(self, modified_files: List[str]) -> None:
+        """更新上下文管理器：当文件被修改后，更新符号表和依赖图"""
+        if not modified_files:
+            return
+        PrettyOutput.auto_print("🔄 正在更新代码上下文...")
+        for file_path in modified_files:
+            import os
+
+            if os.path.exists(file_path):
+                try:
+                    with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+                        content = f.read()
+                    self.context_manager.update_context_for_file(file_path, content)
+                except Exception:
+                    # 如果读取文件失败，跳过更新
+                    pass
+
+    def analyze_edit_impact(self, modified_files: List[str]) -> Optional[Any]:
+        """进行影响范围分析（如果启用）
+
+        Returns:
+            ImpactReport: 影响分析报告，如果未启用或失败则返回None
+        """
+        if not is_enable_impact_analysis():
+            return None
+
+        PrettyOutput.auto_print("🔍 正在进行变更影响分析...")
+        try:
+            impact_analyzer = ImpactAnalyzer(self.context_manager)
+            all_edits = []
+            import os
+
+            for file_path in modified_files:
+                if os.path.exists(file_path):
+                    edits = parse_git_diff_to_edits(file_path, self.root_dir)
+                    all_edits.extend(edits)
+
+            if not all_edits:
+                return None
+
+            # 按文件分组编辑
+            edits_by_file: Dict[str, List[Edit]] = {}
+            for edit in all_edits:
+                if edit.file_path not in edits_by_file:
+                    edits_by_file[edit.file_path] = []
+                edits_by_file[edit.file_path].append(edit)
+
+            # 对每个文件进行影响分析
+            impact_report = None
+            for file_path, edits in edits_by_file.items():
+                report = impact_analyzer.analyze_edit_impact(file_path, edits)
+                if report:
+                    # 合并报告
+                    if impact_report is None:
+                        impact_report = report
+                    else:
+                        # 合并多个报告，去重
+                        impact_report.affected_files = list(
+                            set(impact_report.affected_files + report.affected_files)
+                        )
+
+                        # 合并符号（基于文件路径和名称去重）
+                        symbol_map: Dict[Tuple[str, str, str], Any] = {}
+                        for symbol in (
+                            impact_report.affected_symbols + report.affected_symbols
+                        ):
+                            key = (
+                                symbol.file_path,
+                                symbol.name,
+                                str(symbol.line_start),
+                            )
+                            if key not in symbol_map:
+                                symbol_map[key] = symbol
+                        impact_report.affected_symbols = list(symbol_map.values())
+
+                        impact_report.affected_tests = list(
+                            set(impact_report.affected_tests + report.affected_tests)
+                        )
+
+                        # 合并接口变更（基于符号名和文件路径去重）
+                        interface_map: Dict[Tuple[str, str, str], Any] = {}
+                        for change in (
+                            impact_report.interface_changes + report.interface_changes
+                        ):
+                            key = (
+                                change.file_path,
+                                change.symbol_name,
+                                str(change.change_type),
+                            )
+                            if key not in interface_map:
+                                interface_map[key] = change
+                        impact_report.interface_changes = list(interface_map.values())
+
+                        impact_report.impacts.extend(report.impacts)
+
+                        # 合并建议
+                        impact_report.recommendations = list(
+                            set(impact_report.recommendations + report.recommendations)
+                        )
+
+                        # 使用更高的风险等级
+                        if (
+                            report.risk_level.value == "high"
+                            or impact_report.risk_level.value == "high"
+                        ):
+                            impact_report.risk_level = (
+                                report.risk_level
+                                if report.risk_level.value == "high"
+                                else impact_report.risk_level
+                            )
+                        elif report.risk_level.value == "medium":
+                            impact_report.risk_level = report.risk_level
+
+            return impact_report
+        except Exception as e:
+            # 影响分析失败不应该影响主流程，仅记录日志
+            PrettyOutput.auto_print(f"⚠️ 影响范围分析失败: {e}")
+            return None
+
+    def handle_impact_report(
+        self, impact_report: Optional[Any], agent: Any, final_ret: str
+    ) -> str:
+        """处理影响范围分析报告
+
+        Args:
+            impact_report: 影响分析报告
+            agent: Agent实例
+            final_ret: 当前的结果字符串
+
+        Returns:
+            更新后的结果字符串
+        """
+        if not impact_report:
+            return final_ret
+
+        impact_summary = impact_report.to_string(self.root_dir)
+        final_ret += f"\n\n{impact_summary}\n"
+
+        # 如果是高风险，在提示词中提醒
+        if impact_report.risk_level.value == "high":
+            agent.set_addon_prompt(
+                f"{agent.get_addon_prompt() or ''}\n\n"
+                f"⚠️ 高风险编辑警告：\n"
+                f"检测到此编辑为高风险操作，请仔细检查以下内容：\n"
+                f"- 受影响文件: {len(impact_report.affected_files)} 个\n"
+                f"- 接口变更: {len(impact_report.interface_changes)} 个\n"
+                f"- 相关测试: {len(impact_report.affected_tests)} 个\n"
+                f"建议运行相关测试并检查所有受影响文件。"
+            )
+
+        return final_ret

jarvis/jarvis_code_agent/code_agent_lint.py

@@ -0,0 +1,283 @@
+"""CodeAgent 静态分析模块"""
+
+import os
+import subprocess
+
+from jarvis.jarvis_utils.output import PrettyOutput
+
+# -*- coding: utf-8 -*-
+from typing import Any
+from typing import List
+from typing import Optional
+from typing import Tuple
+
+from jarvis.jarvis_code_agent.lint import LINT_COMMAND_TEMPLATES_BY_FILE
+from jarvis.jarvis_code_agent.lint import get_lint_commands_for_files
+from jarvis.jarvis_code_agent.lint import group_commands_by_template
+from jarvis.jarvis_utils.config import is_enable_static_analysis
+
+
+class LintManager:
+    """静态分析管理器"""
+
+    def __init__(self, root_dir: str):
+        self.root_dir = root_dir
+
+    def run_static_analysis(
+        self, modified_files: List[str]
+    ) -> List[Tuple[str, str, int, str]]:
+        """执行静态分析
+
+        Args:
+            modified_files: 修改的文件列表
+
+        Returns:
+            [(file_path, command, returncode, output), ...] 格式的结果列表
+            只返回有错误或警告的结果（returncode != 0）
+        """
+        if not modified_files:
+            return []
+
+        # 获取所有lint命令
+        commands = get_lint_commands_for_files(modified_files, self.root_dir)
+        if not commands:
+            return []
+
+        # 输出静态检查日志
+        file_count = len(modified_files)
+        files_str = ", ".join(os.path.basename(f) for f in modified_files[:3])
+        if file_count > 3:
+            files_str += f" 等{file_count}个文件"
+        # 从命令中提取工具名（第一个单词）
+        tool_names = list(set(cmd[1].split()[0] for cmd in commands if cmd[1].split()))
+        tools_str = ", ".join(tool_names[:3])
+        if len(tool_names) > 3:
+            tools_str += f" 等{len(tool_names)}个工具"
+        PrettyOutput.auto_print("🔍 静态检查中...")
+
+        results = []
+        # 记录每个文件的检查结果
+        file_results = []  # [(file_name, command, status, message), ...]
+
+        # 按命令模板分组，相同工具可以批量执行
+        grouped = group_commands_by_template(commands)
+
+        for template_key, file_commands in grouped.items():
+            for file_path, command in file_commands:
+                file_name = os.path.basename(file_path)
+                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):
+                        file_results.append((file_name, command, "跳过", "文件不存在"))
+                        continue
+
+                    # 打印执行的命令
+                    PrettyOutput.auto_print(f"ℹ️ 执行: {command}")
+
+                    # 执行命令
+                    result = subprocess.run(
+                        command,
+                        shell=True,
+                        cwd=self.root_dir,
+                        capture_output=True,
+                        text=True,
+                        encoding="utf-8",
+                        errors="replace",
+                        timeout=600,  # 600秒超时
+                    )
+
+                    # 只记录有错误或警告的结果
+                    if result.returncode != 0:
+                        output = result.stdout + result.stderr
+                        if output.strip():  # 有输出才记录
+                            results.append(
+                                (
+                                    file_path,
+                                    command,
+                                    result.returncode,
+                                    output,
+                                )
+                            )
+                            file_results.append(
+                                (file_name, command, "失败", "发现问题")
+                            )
+                            # 失败时打印检查结果
+                            output_preview = (
+                                output[:2000] if len(output) > 2000 else output
+                            )
+                            PrettyOutput.auto_print(
+                                f"⚠️ 检查失败 ({file_name}):\n{output_preview}"
+                            )
+                            if len(output) > 2000:
+                                PrettyOutput.auto_print(
+                                    f"⚠️ ... (输出已截断，共 {len(output)} 字符)"
+                                )
+                        else:
+                            file_results.append((file_name, command, "通过", ""))
+                    else:
+                        file_results.append((file_name, command, "通过", ""))
+
+                except subprocess.TimeoutExpired:
+                    results.append((file_path, command, -1, "执行超时（600秒）"))
+                    file_results.append(
+                        (file_name, command, "超时", "执行超时（600秒）")
+                    )
+                    PrettyOutput.auto_print(
+                        f"⚠️ 检查超时 ({file_name}): 执行超时（600秒）"
+                    )
+                except FileNotFoundError:
+                    # 工具未安装，跳过
+                    file_results.append((file_name, command, "跳过", "工具未安装"))
+                    continue
+                except Exception as e:
+                    # 其他错误，记录但继续
+                    PrettyOutput.auto_print(f"⚠️ 执行lint命令失败: {command}, 错误: {e}")
+                    file_results.append(
+                        (file_name, command, "失败", f"执行失败: {str(e)[:50]}")
+                    )
+                    continue
+
+        # 一次性打印所有检查结果
+        if file_results:
+            total_files = len(file_results)
+            passed_count = sum(
+                1 for _, _, status, _ in file_results if status == "通过"
+            )
+            failed_count = sum(
+                1 for _, _, status, _ in file_results if status == "失败"
+            )
+            timeout_count = sum(
+                1 for _, _, status, _ in file_results if status == "超时"
+            )
+            sum(1 for _, _, status, _ in file_results if status == "跳过")
+
+            # 收缩为一行的结果摘要
+            summary = f"🔍 静态检查: {total_files}个文件"
+            if failed_count > 0:
+                summary += f", {failed_count}失败"
+            if timeout_count > 0:
+                summary += f", {timeout_count}超时"
+            if passed_count == total_files:
+                summary += " ✅全部通过"
+
+            if failed_count > 0 or timeout_count > 0:
+                PrettyOutput.auto_print(f"⚠️ {summary}")
+            else:
+                PrettyOutput.auto_print(f"✅ {summary}")
+        else:
+            PrettyOutput.auto_print("✅ 静态检查完成")
+
+        return results
+
+    def format_lint_results(self, results: List[Tuple[str, str, int, str]]) -> str:
+        """格式化lint结果
+
+        Args:
+            results: [(file_path, command, returncode, output), ...]
+
+        Returns:
+            格式化的错误信息字符串
+        """
+        if not results:
+            return ""
+
+        lines = []
+        for file_path, command, returncode, output in results:
+            # 从命令中提取工具名（第一个单词）
+            tool_name = command.split()[0] if command.split() else "unknown"
+            lines.append(f"工具: {tool_name}")
+            lines.append(f"文件: {file_path}")
+            lines.append(f"命令: {command}")
+            if returncode == -1:
+                lines.append(f"错误: {output}")
+            else:
+                # 限制输出长度，避免过长
+                output_preview = output[:1000] if len(output) > 1000 else output
+                lines.append(f"输出:\n{output_preview}")
+                if len(output) > 1000:
+                    lines.append(f"... (输出已截断，共 {len(output)} 字符)")
+            lines.append("")  # 空行分隔
+
+        return "\n".join(lines)
+
+    def handle_static_analysis(
+        self,
+        modified_files: List[str],
+        build_validation_result: Optional[Any],
+        config: Any,
+        agent: Any,
+        final_ret: str,
+    ) -> str:
+        """处理静态分析
+
+        Returns:
+            更新后的结果字符串
+        """
+        # 检查是否启用静态分析
+        if not is_enable_static_analysis():
+            PrettyOutput.auto_print("ℹ️ 静态分析已禁用，跳过静态检查")
+            return final_ret
+
+        # 检查是否有可用的lint工具
+        def get_lint_tool_names(file_path: str) -> List[str]:
+            """获取文件的lint工具名称列表"""
+            filename = os.path.basename(file_path)
+            filename_lower = filename.lower()
+            templates = LINT_COMMAND_TEMPLATES_BY_FILE.get(filename_lower, [])
+            if not templates:
+                ext = os.path.splitext(filename)[1]
+                if ext:
+                    templates = LINT_COMMAND_TEMPLATES_BY_FILE.get(ext.lower(), [])
+            # 提取工具名（命令模板的第一个单词）
+            return [
+                template.split()[0] if template.split() else "unknown"
+                for template in templates
+            ]
+
+        lint_tools_info = "\n".join(
+            f"   - {file}: 使用 {'、'.join(get_lint_tool_names(file))}"
+            for file in modified_files
+            if get_lint_tool_names(file)
+        )
+
+        if not lint_tools_info:
+            PrettyOutput.auto_print("ℹ️ 未找到可用的静态检查工具，跳过静态检查")
+            return final_ret
+
+        # 如果构建验证失败且未禁用，不进行静态分析（避免重复错误）
+        # 如果构建验证已禁用，则进行静态分析（因为只做了基础静态检查）
+        should_skip_static = (
+            build_validation_result
+            and not build_validation_result.success
+            and not config.is_build_validation_disabled()
+        )
+
+        if should_skip_static:
+            PrettyOutput.auto_print("ℹ️ 构建验证失败，跳过静态分析（避免重复错误）")
+            return final_ret
+
+        # 直接执行静态扫描
+        lint_results = self.run_static_analysis(modified_files)
+        if lint_results:
+            # 有错误或警告，让大模型修复
+            errors_summary = self.format_lint_results(lint_results)
+            # 打印完整的检查结果
+            PrettyOutput.auto_print(f"⚠️ 静态扫描发现问题:\n{errors_summary}")
+            addon_prompt = f"""
+静态扫描发现以下问题，请根据错误信息修复代码:
+
+{errors_summary}
+
+请仔细检查并修复所有问题。
+            """
+            agent.set_addon_prompt(addon_prompt)
+            final_ret += "\n\n⚠️ 静态扫描发现问题，已提示修复\n"
+        else:
+            final_ret += "\n\n✅ 静态扫描通过\n"
+
+        return final_ret

jarvis/jarvis_code_agent/code_agent_llm.py

@@ -0,0 +1,159 @@
+"""CodeAgent LLM 询问模块"""
+
+from typing import Any
+from typing import Dict
+
+from jarvis.jarvis_utils.output import PrettyOutput
+
+# -*- coding: utf-8 -*-
+from typing import Optional
+
+from jarvis.jarvis_platform.registry import PlatformRegistry
+from jarvis.jarvis_utils.config import get_normal_model_name
+from jarvis.jarvis_utils.config import get_normal_platform_name
+from jarvis.jarvis_utils.globals import get_global_model_group
+
+
+class LLMManager:
+    """LLM 询问管理器"""
+
+    def __init__(
+        self, parent_model: Optional[Any] = None, model_group: Optional[str] = None
+    ):
+        """初始化LLM管理器
+
+        Args:
+            parent_model: 父Agent的模型实例（已废弃，保留参数兼容性）
+            model_group: 模型组名称，如果提供则优先使用，否则使用全局模型组
+        """
+        # 保存配置信息，用于后续创建 LLM 实例
+        self._platform_name = None
+        self._model_name = None
+        # 优先使用传入的model_group，否则使用全局模型组
+        self._model_group = model_group or get_global_model_group()
+
+        # 根据 model_group 获取配置（不再从 parent_model 继承）
+        # 使用普通模型，LLM询问可以降低成本
+        if self._model_group:
+            try:
+                self._platform_name = get_normal_platform_name(self._model_group)
+                self._model_name = get_normal_model_name(self._model_group)
+            except Exception:
+                # 如果从 model_group 解析失败，回退到从 parent_model 获取的值
+                pass
+
+        # 如果仍未获取到，使用默认配置
+        if not self._platform_name:
+            self._platform_name = get_normal_platform_name(None)
+        if not self._model_name:
+            self._model_name = get_normal_model_name(None)
+
+    def _create_llm_model(self):
+        """创建新的 LLM 模型实例
+
+        每次调用都创建新的实例，避免上下文窗口累积。
+
+        Returns:
+            LLM 模型实例
+
+        Raises:
+            ValueError: 如果无法创建LLM模型
+        """
+        try:
+            registry = PlatformRegistry.get_global_platform_registry()
+
+            # 创建平台实例
+            if self._platform_name:
+                llm_model = registry.create_platform(self._platform_name)
+                if llm_model is None:
+                    # 如果创建失败，使用普通平台
+                    llm_model = registry.get_normal_platform()
+            else:
+                llm_model = registry.get_normal_platform()
+
+            if not llm_model:
+                raise ValueError("无法创建LLM模型实例")
+
+            # 先设置模型组（如果从父Agent获取到），因为 model_group 可能会影响模型名称的解析
+            if self._model_group:
+                try:
+                    llm_model.set_model_group(self._model_group)
+                except Exception:
+                    pass
+
+            # 然后设置模型名称（如果从父Agent或model_group获取到）
+            if self._model_name:
+                try:
+                    llm_model.set_model_name(self._model_name)
+                except Exception:
+                    pass
+
+            # 设置抑制输出，因为这是后台任务
+            llm_model.set_suppress_output(True)
+
+            return llm_model
+        except Exception as e:
+            raise ValueError(f"无法创建LLM模型: {e}")
+
+    def ask_llm_about_large_deletion(
+        self, detection_result: Dict[str, int], preview: str
+    ) -> bool:
+        """询问大模型大量代码删除是否合理
+
+        参数:
+            detection_result: 检测结果字典，包含 'insertions', 'deletions', 'net_deletions'
+            preview: 补丁预览内容
+
+        返回:
+            bool: 如果大模型认为合理返回True，否则返回False
+        """
+        insertions = detection_result["insertions"]
+        deletions = detection_result["deletions"]
+        net_deletions = detection_result["net_deletions"]
+
+        prompt = f"""检测到大量代码删除，请判断是否合理：
+
+统计信息：
+- 新增行数: {insertions}
+- 删除行数: {deletions}
+- 净删除行数: {net_deletions}
+
+补丁预览：
+{preview}
+
+请仔细分析以上代码变更，判断这些大量代码删除是否合理。可能的情况包括：
+1. 重构代码，删除冗余或过时的代码
+2. 简化实现，用更简洁的代码替换复杂的实现
+3. 删除未使用的代码或功能
+4. 错误地删除了重要代码
+
+请使用以下协议回答（必须包含且仅包含以下标记之一）：
+- 如果认为这些删除是合理的，回答: <!!!YES!!!>
+- 如果认为这些删除不合理或存在风险，回答: <!!!NO!!!>
+
+请严格按照协议格式回答，不要添加其他内容。
+"""
+
+        try:
+            PrettyOutput.auto_print("🤖 正在询问大模型判断大量代码删除是否合理...")
+            # 每次调用都创建新的 LLM 实例，避免上下文窗口累积
+            llm_model = self._create_llm_model()
+            response = llm_model.chat_until_success(prompt)
+
+            # 使用确定的协议标记解析回答
+            if "<!!!YES!!!>" in response:
+                PrettyOutput.auto_print("✅ 大模型确认：代码删除合理")
+                return True
+            elif "<!!!NO!!!>" in response:
+                PrettyOutput.auto_print("⚠️ 大模型确认：代码删除不合理")
+                return False
+            else:
+                # 如果无法找到协议标记，默认认为不合理（保守策略）
+                PrettyOutput.auto_print(
+                    f"⚠️ 无法找到协议标记，默认认为不合理。回答内容: {response[:200]}"
+                )
+                return False
+        except Exception as e:
+            # 如果询问失败，默认认为不合理（保守策略）
+            PrettyOutput.auto_print(f"⚠️ 询问大模型失败: {str(e)}，默认认为不合理")
+            return False