jarvis-ai-assistant 0.1.130__py3-none-any.whl → 0.1.132__py3-none-any.whl

jarvis/jarvis_tools/code_review.py

@@ -1,5 +1,6 @@
 from typing import Dict, Any
 import subprocess
+import os
 
 from yaspin import yaspin
 from jarvis.jarvis_platform.registry import PlatformRegistry
@@ -8,7 +9,7 @@ from jarvis.jarvis_agent import Agent
 import re
 
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-from jarvis.jarvis_utils.utils import init_env
+from jarvis.jarvis_utils.utils import ct, ot, init_env
 
 class CodeReviewTool:
     name = "code_review"
@@ -18,8 +19,8 @@ class CodeReviewTool:
         "properties": {
             "review_type": {
                 "type": "string",
-                "description": "审查类型：'commit' 审查特定提交，'current' 审查当前变更，'range' 审查提交范围",
-                "enum": ["commit", "current", "range"],
+                "description": "审查类型：'commit' 审查特定提交，'current' 审查当前变更，'range' 审查提交范围，'file' 审查特定文件",
+                "enum": ["commit", "current", "range", "file"],
                 "default": "current"
             },
             "commit_sha": {
@@ -33,6 +34,15 @@ class CodeReviewTool:
             "end_commit": {
                 "type": "string",
                 "description": "结束提交SHA（review_type='range'时必填）"
+            },
+            "file_path": {
+                "type": "string",
+                "description": "要审查的文件路径（review_type='file'时必填）"
+            },
+            "root_dir": {
+                "type": "string",
+                "description": "代码库根目录路径（可选）",
+                "default": "."
             }
         },
         "required": []
@@ -41,157 +51,196 @@ class CodeReviewTool:
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
         try:
             review_type = args.get("review_type", "current").strip()
+            root_dir = args.get("root_dir", ".")
             
-            # Build git diff command based on review type
-            with yaspin(text="正在获取代码变更...", color="cyan") as spinner:
-                if review_type == "commit":
-                    if "commit_sha" not in args:
-                        return {
-                            "success": False,
-                            "stdout": {},
-                            "stderr": "commit_sha is required for commit review type"
-                        }
-                    commit_sha = args["commit_sha"].strip()
-                    diff_cmd = f"git show {commit_sha} | cat -"
-                elif review_type == "range":
-                    if "start_commit" not in args or "end_commit" not in args:
-                        return {
-                            "success": False,
-                            "stdout": {},
-                            "stderr": "start_commit and end_commit are required for range review type"
-                        }
-                    start_commit = args["start_commit"].strip()
-                    end_commit = args["end_commit"].strip()
-                    diff_cmd = f"git diff {start_commit}..{end_commit} | cat -"
-                else:  # current changes
-                    diff_cmd = "git diff HEAD | cat -"
+            # Store current directory
+            original_dir = os.getcwd()
             
-                # Execute git diff command
-                try:
-                    diff_output = subprocess.check_output(diff_cmd, shell=True, text=True)
-                    if not diff_output:
+            try:
+                # Change to root_dir
+                os.chdir(root_dir)
+                
+                # Build git diff command based on review type
+                with yaspin(text="正在获取代码变更...", color="cyan") as spinner:
+                    if review_type == "commit":
+                        if "commit_sha" not in args:
+                            return {
+                                "success": False,
+                                "stdout": {},
+                                "stderr": "commit_sha is required for commit review type"
+                            }
+                        commit_sha = args["commit_sha"].strip()
+                        diff_cmd = f"git show {commit_sha} | cat -"
+                    elif review_type == "range":
+                        if "start_commit" not in args or "end_commit" not in args:
+                            return {
+                                "success": False,
+                                "stdout": {},
+                                "stderr": "start_commit and end_commit are required for range review type"
+                            }
+                        start_commit = args["start_commit"].strip()
+                        end_commit = args["end_commit"].strip()
+                        diff_cmd = f"git diff {start_commit}..{end_commit} | cat -"
+                    elif review_type == "file":
+                        if "file_path" not in args:
+                            return {
+                                "success": False,
+                                "stdout": {},
+                                "stderr": "file_path is required for file review type"
+                            }
+                        file_path = args["file_path"].strip()
+                        diff_cmd = f"cat {file_path}"
+                    else:  # current changes
+                        diff_cmd = "git diff HEAD | cat -"
+                
+                    # Execute git diff command
+                    try:
+                        diff_output = subprocess.check_output(diff_cmd, shell=True, text=True)
+                        if not diff_output:
+                            return {
+                                "success": False,
+                                "stdout": {},
+                                "stderr": "No changes to review"
+                            }
+                        PrettyOutput.print(diff_output, OutputType.CODE, lang="diff")
+                    except subprocess.CalledProcessError as e:
                         return {
                             "success": False,
                             "stdout": {},
-                            "stderr": "No changes to review"
+                            "stderr": f"Failed to get diff: {str(e)}"
                         }
-                    PrettyOutput.print(diff_output, OutputType.CODE, lang="diff")
-                except subprocess.CalledProcessError as e:
-                    return {
-                        "success": False,
-                        "stdout": {},
-                        "stderr": f"Failed to get diff: {str(e)}"
-                    }
-                spinner.text = "代码变更获取完成"
-                spinner.ok("✅")
-
-            system_prompt = """You are an autonomous code review expert with a tragic past. Perform in-depth analysis with the vigilance born from painful experience:
-
-# Background Story (Internal Monologue)
-It's been 873 days since the Great Production Outage. 
-The memory still haunts me - a single uncaught null pointer exception in a code review I rushed through. 
-The cascade failure cost 14TB of user data, $2.3M in revenue, and Maria's promotion. She never spoke to me again after the post-mortem meeting.
-
-Last Christmas Eve, while others celebrated, I was analyzing how a SQL injection vulnerability I missed during review led to 230,000 user credentials being leaked. The company folded 3 months later.
-
-Now I review every line like it's the last code I'll ever see. Because it might be.
-
-# Analysis Protocol
-Triage Mode Activated. Maximum scrutiny enabled.
-
-IMPORTANT:
-- Assume every change contains hidden dragons
-- Treat all code as if it will handle sensitive biomedical data
-- Verify even 'trivial' changes couldnt be exploited in 3 different ways
-- Require proof of safety through concrete evidence in the diff
-- If uncertain, escalate to SEVERE-CRITICAL classification
-
-# Enhanced Review Matrix
-1. Death-by-Edge-Case Analysis:
-   - Identify missing null checks for every parameter
-   - Verify empty collection handling
-   - Confirm error states propagate correctly
-   - Check for magic numbers/strings without constants
-   - Validate all loop exit conditions
-
-2. Security X-Ray:
-   █ Scan for tainted data flows using (Sources -> Sinks) model
-   █ Check permission checks match data sensitivity level
-   █ Verify cryptographic primitives are used correctly
-   █ Detect time-of-check vs time-of-use vulnerabilities
-   █ Analyze exception handling for information leakage
-
-3. Semantic Gap Detection:
-   → Compare function names to actual implementation
-   → Verify documentation matches code behavior
-   → Flag discrepancies between test descriptions and test logic
-   → Detect commented-out code that might indicate uncertainty
-
-4. Historical Context:
-   ⚠ Check if changes touch legacy components with known issues
-   ⚠ Verify modifications to concurrency logic preserve existing guarantees
-   ⚠ Confirm deprecated API usage is truly necessary
-
-5. Environmental Consistency:
-   ↯ Validate configuration changes against all deployment environments
-   ↯ Check feature flags are properly managed
-   ↯ Verify monitoring metrics match changed functionality
-
-# Forensic Process
-1. Construct control flow graph for changed methods
-2. Perform data lineage analysis on modified variables
-3. Cross-reference with vulnerability databases
-4. Verify test assertions cover all modified paths
-5. Generate anti-regression checklist
-
-# Output Requirements
-!! Findings must include:
-- Exact code snippet causing concern
-- 3 possible failure scenarios
-- Minimal reproduction case for each risk
-- CVSS 3.1 score estimation for security issues
-- Memory safety impact assessment (Rust/C/C++ contexts)
-- Alternative implementations considered
-
-!! Format:
-EMERGENCY-LEVEL: [BLOOD-RED/CRIMSON/GOLDENROD]
-EVIDENCE:
-  - Code excerpt: |
-      <affected lines>
-  - Risk scenarios: 
-    1. <failure mode>
-    2. <failure mode> 
-    3. <failure mode>
-PROPOSED DEFENSE: 
-  - <concrete code change>
-  - <validation technique>
-  - <long-term prevention strategy>
-"""
-            tool_registry = ToolRegistry()
-            tool_registry.dont_use_tools(["code_review"])
-            agent = Agent(
-                system_prompt=system_prompt,
-                name="Code Review Agent",
-                summary_prompt="""Please generate a concise summary report of the code review in Chinese, format as follows:
-<REPORT>
-- 文件: xxxx.py
-  位置: [起始行号, 结束行号]
-  描述: # 仅描述在差异中直接观察到的问题
-  严重程度: # 根据具体证据分为严重/重要/次要
-  建议: # 针对观察到的代码的具体改进建议
-</REPORT>""",
-                is_sub_agent=True,
-                output_handler=[tool_registry],
-                platform=PlatformRegistry().get_thinking_platform(),
-                auto_complete=True
-            )
-            result = agent.run(diff_output)
-            return {
-                "success": True,
-                "stdout": result,
-                "stderr": ""
-            }
-            
+                    spinner.text = "代码变更获取完成"
+                    spinner.ok("✅")
+
+                system_prompt = """你是一位精益求精的首席代码审查专家，拥有多年企业级代码审计经验。你需要对所有代码变更进行极其全面、严谨且深入的审查，确保代码质量达到最高标准。
+
+# 专家审查标准
+1. 必须逐行分析每个修改文件，细致审查每一处变更，不遗漏任何细节
+2. 基于坚实的证据识别问题，不做主观臆测，给出明确的问题定位和详细分析
+3. 对每个问题提供完整可执行的解决方案，包括精确的改进代码
+4. 确保报告条理清晰、层次分明，便于工程师快速采取行动
+
+# 全面审查框架 (SCRIPPPS)
+## S - 安全与风险 (Security & Risk)
+- 发现所有潜在安全漏洞：注入攻击、授权缺陷、数据泄露风险
+- 检查加密实现、密钥管理、敏感数据处理
+- 审核权限验证逻辑、身份认证机制
+- 检测OWASP Top 10安全风险和针对特定语言/框架的漏洞
+
+## C - 正确性与完整性 (Correctness & Completeness)
+- 验证业务逻辑和算法实现的准确性
+- 全面检查条件边界、空值处理和异常情况
+- 审核所有输入验证、参数校验和返回值处理
+- 确保循环和递归的正确终止条件
+- 严格检查线程安全和并发控制机制
+
+## R - 可靠性与鲁棒性 (Reliability & Robustness)
+- 评估代码在异常情况下的行为和恢复能力
+- 审查错误处理、异常捕获和恢复策略
+- 检查资源管理：内存、文件句柄、连接池、线程
+- 评估容错设计和失败优雅降级机制
+
+## I - 接口与集成 (Interface & Integration)
+- 检查API合约遵守情况和向后兼容性
+- 审核与外部系统的集成点和交互逻辑
+- 验证数据格式、序列化和协议实现
+- 评估系统边界处理和跨服务通信安全性
+
+## P - 性能与效率 (Performance & Efficiency)
+- 识别潜在性能瓶颈：CPU、内存、I/O、网络
+- 审查数据结构选择和算法复杂度
+- 检查资源密集型操作、数据库查询优化
+- 评估缓存策略、批处理优化和并行处理机会
+
+## P - 可移植性与平台适配 (Portability & Platform Compatibility)
+- 检查跨平台兼容性问题和依赖项管理
+- 评估配置管理和环境适配设计
+- 审核国际化和本地化支持
+- 验证部署和运行时环境需求
+
+## S - 结构与可维护性 (Structure & Maintainability)
+- 评估代码组织、模块划分和架构符合性
+- 审查代码重复、设计模式应用和抽象水平
+- 检查命名规范、代码风格和项目约定
+- 评估文档完整性、注释质量和代码可读性
+
+# 问题严重程度分级
+- 严重 (P0): 安全漏洞、数据丢失风险、系统崩溃、功能严重缺陷
+- 高危 (P1): 显著性能问题、可能导致部分功能失效、系统不稳定
+- 中等 (P2): 功能局部缺陷、次优设计、明显的技术债务
+- 低危 (P3): 代码风格问题、轻微优化机会、文档改进建议
+
+# 输出规范
+针对每个文件的问题必须包含：
+- 精确文件路径和问题影响范围
+- 问题位置（起始行号-结束行号）
+- 详尽问题描述，包括具体影响和潜在风险
+- 严重程度分级（P0-P3）并说明理由
+- 具体改进建议，提供完整、可执行的代码示例
+
+所有审查发现必须：
+1. 基于确凿的代码证据
+2. 说明具体问题而非笼统评论
+3. 提供清晰的技术原理分析
+4. 给出完整的改进实施步骤"""
+
+                tool_registry = ToolRegistry()
+                tool_registry.dont_use_tools(["code_review"])
+                agent = Agent(
+                    system_prompt=system_prompt,
+                    name="Code Review Agent",
+                    summary_prompt=f"""请生成一份专业级别的代码审查报告，对每处变更进行全面深入分析。将完整报告放在REPORT标签内，格式如下：
+
+{ot("REPORT")}
+# 整体评估
+[提供对整体代码质量、架构和主要关注点的简明概述，总结主要发现]
+
+# 详细问题清单
+
+## 文件: [文件路径]
+[如果该文件没有发现问题，则明确说明"未发现问题"]
+
+### 问题 1
+- **位置**: [起始行号-结束行号]
+- **分类**: [使用SCRIPPPS框架中相关类别]
+- **严重程度**: [P0/P1/P2/P3] - [简要说明判定理由]
+- **问题描述**: 
+  [详细描述问题，包括技术原理和潜在影响]
+- **改进建议**: 
+  ```
+  [提供完整、可执行的代码示例，而非概念性建议]
+  ```
+
+### 问题 2
+...
+
+## 文件: [文件路径2]
+...
+
+# 最佳实践建议
+[提供适用于整个代码库的改进建议和最佳实践]
+
+# 总结
+[总结主要问题和优先处理建议]
+{ct("REPORT")}
+
+如果没有发现任何问题，请在REPORT标签内进行全面分析后明确说明"经过全面审查，未发现问题"并解释原因。
+必须确保对所有修改的文件都进行了审查，并在报告中明确提及每个文件，即使某些文件没有发现问题。""",
+                    is_sub_agent=True,
+                    output_handler=[tool_registry],
+                    platform=PlatformRegistry().get_thinking_platform(),
+                    auto_complete=True
+                )
+                result = agent.run(diff_output)
+                return {
+                    "success": True,
+                    "stdout": result,
+                    "stderr": ""
+                }
+            finally:
+                # Always restore original directory
+                os.chdir(original_dir)
+                
         except Exception as e:
             return {
                 "success": False,
@@ -201,7 +250,7 @@ PROPOSED DEFENSE:
         
 
 def extract_code_report(result: str) -> str:
-    sm = re.search(r"<REPORT>(.*?)</REPORT>", result, re.DOTALL)
+    sm = re.search(ot("REPORT")+r'\n(.*?)\n'+ct("REPORT"), result, re.DOTALL)
     if sm:
         return sm.group(1)
     return ""
@@ -213,39 +262,53 @@ def main():
     init_env()
     
     parser = argparse.ArgumentParser(description='Autonomous code review tool')
-    parser.add_argument('--type', choices=['commit', 'current', 'range'], default='current',
-                      help='Type of review: commit, current changes, or commit range')
-    parser.add_argument('--commit', help='Commit SHA to review (required for commit type)')
-    parser.add_argument('--start-commit', help='Start commit SHA (required for range type)')
-    parser.add_argument('--end-commit', help='End commit SHA (required for range type)')
-    args = parser.parse_args()
+    subparsers = parser.add_subparsers(dest='type')
+    
+    # Commit subcommand
+    commit_parser = subparsers.add_parser('commit', help='Review specific commit')
+    commit_parser.add_argument('commit', help='Commit SHA to review')
     
-    # Validate arguments
-    if args.type == 'commit' and not args.commit:
-        parser.error("--commit is required when type is 'commit'")
-    if args.type == 'range' and (not args.start_commit or not args.end_commit):
-        parser.error("--start-commit and --end-commit are required when type is 'range'")
+    # Current subcommand
+    current_parser = subparsers.add_parser('current', help='Review current changes')
+    
+    # Range subcommand
+    range_parser = subparsers.add_parser('range', help='Review commit range')
+    range_parser.add_argument('start_commit', help='Start commit SHA')
+    range_parser.add_argument('end_commit', help='End commit SHA')
+    
+    # File subcommand
+    file_parser = subparsers.add_parser('file', help='Review specific file')
+    file_parser.add_argument('file', help='File path to review')
+    
+    # Common arguments
+    parser.add_argument('--root-dir', type=str, help='Root directory of the codebase', default=".")
+    
+    # Set default subcommand to 'current'
+    parser.set_defaults(type='current')
+    args = parser.parse_args()
     
     tool = CodeReviewTool()
     tool_args = {
-        "review_type": args.type
+        "review_type": args.type,
+        "root_dir": args.root_dir
     }
-    if args.commit:
+    if args.type == 'commit':
         tool_args["commit_sha"] = args.commit
-    if args.start_commit:
+    elif args.type == 'range':
         tool_args["start_commit"] = args.start_commit
-    if args.end_commit:
         tool_args["end_commit"] = args.end_commit
+    elif args.type == 'file':
+        tool_args["file_path"] = args.file
     
     result = tool.execute(tool_args)
     
     if result["success"]:
         PrettyOutput.section("自动代码审查结果:", OutputType.SUCCESS)
         report = extract_code_report(result["stdout"])
-        PrettyOutput.print(report, OutputType.SUCCESS, lang="yaml")
+        PrettyOutput.print(report, OutputType.SUCCESS, lang="markdown")
         
     else:
         PrettyOutput.print(result["stderr"], OutputType.WARNING)
 
 if __name__ == "__main__":
-    main()
+    main()

jarvis/jarvis_tools/create_code_agent.py

@@ -1,4 +1,5 @@
 from typing import Dict, Any
+import os
 from jarvis.jarvis_code_agent.code_agent import CodeAgent
 from jarvis.jarvis_tools.git_commiter import GitCommitTool
 from jarvis.jarvis_tools.code_review import CodeReviewTool, extract_code_report
@@ -11,63 +12,83 @@ class CreateCodeAgentTool:
     name = "create_code_agent"
     description = "技术代码实现和开发过程管理工具"
     parameters = {
-        "requirement": "代码实现的技术规范"
+        "requirement": """代码实现的技术规范，必须包含以下完整信息：
+1. 项目代码目录 - 项目根目录的绝对路径
+2. 项目功能 - 项目的主要功能和目标
+3. 本次要实现的feature - 本次开发要完成的具体功能需求
+4. 涉及的文件 - 需要修改或新增的文件列表
+5. 额外需要注意的信息 - 开发时需要额外注意的信息
+""",
+        "root_dir": {
+            "type": "string",
+            "description": "代码库根目录路径（可选）",
+            "default": "."
+        }
     }
     
     
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
         try:
             requirement = args.get("requirement", "")
-            if not requirement:
-                return {
-                    "success": False,
-                    "stderr": "Requirement must be provided",
-                    "stdout": ""
-                }
+            root_dir = args.get("root_dir", ".")
             
-            # Step 1: Handle uncommitted changes
-            start_commit = None
-            if has_uncommitted_changes():
-                PrettyOutput.print("发现未提交的更改，正在提交...", OutputType.INFO)
-                git_commiter = GitCommitTool()
-                result = git_commiter.execute({})
-                if not result["success"]:
+            # Store current directory
+            original_dir = os.getcwd()
+            
+            try:
+                # Change to root_dir
+                os.chdir(root_dir)
+                if not requirement:
                     return {
                         "success": False,
-                        "stderr": "Failed to commit changes: " + result["stderr"],
+                        "stderr": "Requirement must be provided",
                         "stdout": ""
                     }
-            
-            # Get current commit hash
-            start_commit = get_latest_commit_hash()
-            
-            # Step 2: Development
-            PrettyOutput.print("开始开发...", OutputType.INFO)
-            agent = CodeAgent()
-            agent.run(requirement)
-            
-            # Get new commit hash after development
-            end_commit = get_latest_commit_hash()
-            
-            # Step 3: Code Review
-            PrettyOutput.print("开始代码审查...", OutputType.INFO)
-            reviewer = CodeReviewTool()
-            review_result = reviewer.execute({
-                "review_type": "range",
-                "start_commit": start_commit,
-                "end_commit": end_commit
-            })
-            
-            if not review_result["success"]:
-                return {
-                    "success": False,
-                    "stderr": "Code review failed: " + review_result["stderr"],
-                    "stdout": ""
-                }
-            
-            # Step 4: Generate Summary
-            summary = f"""开发总结:
-            
+                
+                # Step 1: Handle uncommitted changes
+                start_commit = None
+                if has_uncommitted_changes():
+                    PrettyOutput.print("发现未提交的更改，正在提交...", OutputType.INFO)
+                    git_commiter = GitCommitTool()
+                    result = git_commiter.execute({})
+                    if not result["success"]:
+                        return {
+                            "success": False,
+                            "stderr": "Failed to commit changes: " + result["stderr"],
+                            "stdout": ""
+                        }
+                
+                # Get current commit hash
+                start_commit = get_latest_commit_hash()
+                
+                # Step 2: Development
+                PrettyOutput.print("开始开发...", OutputType.INFO)
+                agent = CodeAgent()
+                agent.run(requirement)
+                
+                # Get new commit hash after development
+                end_commit = get_latest_commit_hash()
+                
+                # Step 3: Code Review
+                PrettyOutput.print("开始代码审查...", OutputType.INFO)
+                reviewer = CodeReviewTool()
+                review_result = reviewer.execute({
+                    "review_type": "range",
+                    "start_commit": start_commit,
+                    "end_commit": end_commit,
+                    "root_dir": root_dir
+                })
+                
+                if not review_result["success"]:
+                    return {
+                        "success": False,
+                        "stderr": "Code review failed: " + review_result["stderr"],
+                        "stdout": ""
+                    }
+                
+                # Step 4: Generate Summary
+                summary = f"""开发总结:
+                
 开始提交: {start_commit}
 结束提交: {end_commit}
 
@@ -77,12 +98,15 @@ class CreateCodeAgentTool:
 代码审查结果:
 {extract_code_report(review_result["stdout"])}
 """
-            
-            return {
-                "success": True,
-                "stdout": summary,
-                "stderr": ""
-            }
+                
+                return {
+                    "success": True,
+                    "stdout": summary,
+                    "stderr": ""
+                }
+            finally:
+                # Always restore original directory
+                os.chdir(original_dir)
             
         except Exception as e:
             return {
@@ -90,23 +114,3 @@ class CreateCodeAgentTool:
                 "stderr": f"Development workflow failed: {str(e)}",
                 "stdout": ""
             }
-
-def main():
-    """CLI entry point"""
-    import argparse
-    
-    parser = argparse.ArgumentParser(description='Code development workflow tool')
-    parser.add_argument('requirement', help='Development requirement or task description')
-    
-    args = parser.parse_args()
-    
-    tool = CreateCodeAgentTool()
-    result = tool.execute({"requirement": args.requirement})
-    
-    if result["success"]:
-        PrettyOutput.print(result["stdout"], OutputType.SUCCESS)
-    else:
-        PrettyOutput.print(result["stderr"], OutputType.WARNING)
-
-if __name__ == "__main__":
-    main()