jarvis-ai-assistant 0.1.103__py3-none-any.whl → 0.1.105__py3-none-any.whl

jarvis/{models → jarvis_platform}/openai.py

@@ -1,7 +1,7 @@
 from typing import Dict, List, Tuple
 import os
 from openai import OpenAI
-from jarvis.models.base import BasePlatform
+from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.utils import PrettyOutput, OutputType
 
 class OpenAIModel(BasePlatform):

jarvis/{models → jarvis_platform}/oyi.py

@@ -1,7 +1,7 @@
 import mimetypes
 import os
 from typing import Dict, List, Tuple
-from jarvis.models.base import BasePlatform
+from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.utils import PrettyOutput, OutputType, get_max_context_length
 import requests
 import json

jarvis/{models → jarvis_platform}/registry.py

@@ -3,8 +3,8 @@ import inspect
 import os
 import sys
 from typing import Dict, Type, Optional, List
-from jarvis.models.base import BasePlatform
-from jarvis.utils import PrettyOutput, OutputType
+from jarvis.jarvis_platform.base import BasePlatform
+from jarvis.utils import PrettyOutput, OutputType, get_cheap_model_name, get_cheap_platform_name, get_codegen_model_name, get_codegen_platform_name, get_normal_model_name, get_normal_platform_name, get_thinking_model_name, get_thinking_platform_name
 
 REQUIRED_METHODS = [
     ('chat', ['message']),           # 方法名和参数列表
@@ -98,7 +98,7 @@ class PlatformRegistry:
         # 获取目录的包名
         package_name = None
         if directory == os.path.dirname(__file__):
-            package_name = "jarvis.models"
+            package_name = "jarvis.jarvis_platform"
             
         # 添加目录到Python路径
         if directory not in sys.path:
@@ -155,29 +155,29 @@ class PlatformRegistry:
         
 
     def get_normal_platform(self) -> BasePlatform:
-        platform_name = os.environ.get("JARVIS_PLATFORM", "kimi")
-        model_name = os.environ.get("JARVIS_MODEL", "kimi")
+        platform_name = get_normal_platform_name()
+        model_name = get_normal_model_name()
         platform = self.create_platform(platform_name)
         platform.set_model_name(model_name) # type: ignore
         return platform # type: ignore
     
     def get_codegen_platform(self) -> BasePlatform:
-        platform_name = os.environ.get("JARVIS_CODEGEN_PLATFORM", os.environ.get("JARVIS_PLATFORM", "kimi"))
-        model_name = os.environ.get("JARVIS_CODEGEN_MODEL", os.environ.get("JARVIS_MODEL", "kimi"))
+        platform_name = get_codegen_platform_name()
+        model_name = get_codegen_model_name()
         platform = self.create_platform(platform_name)
         platform.set_model_name(model_name) # type: ignore
         return platform # type: ignore
     
     def get_cheap_platform(self) -> BasePlatform:
-        platform_name = os.environ.get("JARVIS_CHEAP_PLATFORM", os.environ.get("JARVIS_PLATFORM", "kimi"))
-        model_name = os.environ.get("JARVIS_CHEAP_MODEL", os.environ.get("JARVIS_MODEL", "kimi"))
+        platform_name = get_cheap_platform_name()
+        model_name = get_cheap_model_name()
         platform = self.create_platform(platform_name)
         platform.set_model_name(model_name) # type: ignore
         return platform # type: ignore
     
     def get_thinking_platform(self) -> BasePlatform:
-        platform_name = os.environ.get("JARVIS_THINKING_PLATFORM", os.environ.get("JARVIS_PLATFORM", "kimi"))
-        model_name = os.environ.get("JARVIS_THINKING_MODEL", os.environ.get("JARVIS_MODEL", "kimi"))
+        platform_name = get_thinking_platform_name()
+        model_name = get_thinking_model_name()
         platform = self.create_platform(platform_name)
         platform.set_model_name(model_name) # type: ignore
         return platform # type: ignore

jarvis/{jarvis_platform → jarvis_platform_manager}/main.py

@@ -1,4 +1,4 @@
-from jarvis.models.registry import PlatformRegistry
+from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.utils import PrettyOutput, OutputType, init_env, get_multiline_input
 
 def list_platforms():
@@ -29,7 +29,7 @@ def list_platforms():
                         output += f"  • {model_name} - {description}\n"
                     else:
                         output += f"  • {model_name}\n"
-                PrettyOutput.print(output, OutputType.SUCCESS)
+                PrettyOutput.print(output, OutputType.SUCCESS, lang="markdown")
             else:
                 PrettyOutput.print("  • No available model information", OutputType.WARNING)
                 

jarvis/jarvis_rag/main.py

@@ -3,14 +3,14 @@ import numpy as np
 import faiss
 from typing import List, Tuple, Optional, Dict
 import pickle
-from jarvis.utils import OutputType, PrettyOutput, get_file_md5, get_max_context_length, load_embedding_model, load_rerank_model
+from jarvis.utils import OutputType, PrettyOutput, get_context_window, get_file_md5, get_max_context_length, get_max_paragraph_length, get_min_paragraph_length, get_thread_count, load_embedding_model, load_rerank_model
 from jarvis.utils import init_env
 from dataclasses import dataclass
 from tqdm import tqdm
 import fitz  # PyMuPDF for PDF files
 from docx import Document as DocxDocument  # python-docx for DOCX files
 from pathlib import Path
-from jarvis.models.registry import PlatformRegistry
+from jarvis.jarvis_platform.registry import PlatformRegistry
 import shutil
 from datetime import datetime
 import lzma  # 添加 lzma 导入
@@ -142,9 +142,9 @@ class RAGTool:
         os.chdir(self.root_dir)
         
         # Initialize configuration
-        self.min_paragraph_length = int(os.environ.get("JARVIS_MIN_PARAGRAPH_LENGTH", "50"))  # Minimum paragraph length
-        self.max_paragraph_length = int(os.environ.get("JARVIS_MAX_PARAGRAPH_LENGTH", "1000"))  # Maximum paragraph length
-        self.context_window = int(os.environ.get("JARVIS_CONTEXT_WINDOW", "5"))  # Context window size, default前后各5个片段
+        self.min_paragraph_length = get_min_paragraph_length()  # Minimum paragraph length
+        self.max_paragraph_length = get_max_paragraph_length()  # Maximum paragraph length
+        self.context_window = get_context_window()  # Context window size, default前后各5个片段
         self.max_context_length = int(get_max_context_length() * 0.8)
         
         # Initialize data directory
@@ -179,7 +179,7 @@ class RAGTool:
         ]
 
         # Add thread related configuration
-        self.thread_count = int(os.environ.get("JARVIS_THREAD_COUNT", os.cpu_count() or 4))
+        self.thread_count = get_thread_count()
         self.vector_lock = Lock()  # Protect vector list concurrency
 
     def _load_cache(self):
@@ -699,7 +699,7 @@ Content: {doc.content}
                 output = f"""File: {doc.metadata['file_path']}\n"""
                 output += f"""Fragment {doc.metadata['chunk_index'] + 1}/{doc.metadata['total_chunks']}\n"""
                 output += f"""Content:\n{doc.content}\n"""
-                PrettyOutput.print(output, output_type=OutputType.INFO)
+                PrettyOutput.print(output, output_type=OutputType.INFO, lang="markdown")
 
             # Build base prompt
             base_prompt = f"""Please answer the user's question based on the following document fragments. If the document content is not sufficient to answer the question completely, please clearly indicate.
@@ -792,7 +792,7 @@ def main():
                     output = f"""File: {doc.metadata['file_path']}\n"""
                     output += f"""Fragment {doc.metadata['chunk_index'] + 1}/{doc.metadata['total_chunks']}\n"""
                     output += f"""Content:\n{doc.content}\n"""
-                    PrettyOutput.print(output, output_type=OutputType.INFO)
+                    PrettyOutput.print(output, output_type=OutputType.INFO, lang="markdown")
                 return 0
 
             if args.ask:

jarvis/jarvis_smart_shell/main.py

@@ -7,8 +7,8 @@ from typing import Optional
 from yaspin import yaspin # type: ignore
 from yaspin.spinners import Spinners # type: ignore
 
-from jarvis.models.registry import PlatformRegistry
-from jarvis.utils import PrettyOutput, OutputType, init_env
+from jarvis.jarvis_platform.registry import PlatformRegistry
+from jarvis.utils import PrettyOutput, OutputType, get_shell_name, init_env
 
 def execute_command(command: str) -> None:
     """Show command and allow user to edit, then execute, Ctrl+C to cancel"""
@@ -42,7 +42,7 @@ def process_request(request: str) -> Optional[str]:
         model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
         model.set_suppress_output(True)
 
-        shell = os.environ.get("SHELL") or "bash"
+        shell = get_shell_name()
         current_path = os.getcwd()
         
         # Set system prompt

jarvis/{tools → jarvis_tools}/ask_codebase.py

@@ -87,13 +87,10 @@ def main():
     })
     
     if result["success"]:
-        print(result["stdout"])
+        PrettyOutput.print(result["stdout"], OutputType.INFO, lang="markdown")
     else:
         PrettyOutput.print(result["stderr"], OutputType.ERROR)
-        return 1
         
-    return 0
-
 
 if __name__ == "__main__":
     main()

jarvis/{tools → jarvis_tools}/ask_user.py

@@ -1,5 +1,5 @@
 from typing import Dict, Any
-from jarvis.tools.base import Tool
+from jarvis.jarvis_tools.base import Tool
 from jarvis.utils import get_multiline_input, PrettyOutput, OutputType
 
 class AskUserTool:

jarvis/{tools → jarvis_tools}/chdir.py

@@ -3,8 +3,6 @@ import os
 from jarvis.utils import PrettyOutput, OutputType
 
 class ChdirTool:
-    """修改当前工作目录的工具"""
-    
     name = "chdir"
     description = "Change current working directory"
     parameters = {
@@ -19,22 +17,10 @@ class ChdirTool:
     }
     
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-        """执行目录切换
-        
-        Args:
-            args: 包含 path 参数的字典
-            
-        Returns:
-            执行结果字典，包含:
-            - success: 是否成功
-            - stdout: 成功时的输出信息
-            - error: 失败时的错误信息
-        """
         try:
-            path = os.path.expanduser(args["path"].strip())  # 展开 ~ 等路径
-            path = os.path.abspath(path)  # 转换为绝对路径
+            path = os.path.expanduser(args["path"].strip())
+            path = os.path.abspath(path)
             
-            # 检查目录是否存在
             if not os.path.exists(path):
                 return {
                     "success": False,
@@ -42,7 +28,6 @@ class ChdirTool:
                     "stderr": f"Directory does not exist: {path}"
                 }
                 
-            # 检查是否是目录
             if not os.path.isdir(path):
                 return {
                     "success": False,
@@ -50,7 +35,6 @@ class ChdirTool:
                     "stderr": f"The path is not a directory: {path}"
                 }
                 
-            # 尝试切换目录
             old_path = os.getcwd()
             os.chdir(path)
             
@@ -72,22 +56,3 @@ class ChdirTool:
                 "stdout": "",
                 "stderr": f"Failed to switch directory: {str(e)}"
             }
-            
-def main():
-    """命令行直接运行工具"""
-    import argparse
-    
-    parser = argparse.ArgumentParser(description='Change current working directory')
-    parser.add_argument('path', help='Directory path to switch to, supports both relative and absolute paths')
-    args = parser.parse_args()
-    
-    tool = ChdirTool()
-    result = tool.execute({"path": args.path})
-    
-    if result["success"]:
-        PrettyOutput.print(result["stdout"], OutputType.SUCCESS)
-    else:
-        PrettyOutput.print(result["stderr"], OutputType.ERROR)
-        
-if __name__ == "__main__":
-    main() 

jarvis/jarvis_tools/code_review.py

@@ -0,0 +1,236 @@
+from typing import Dict, Any, List
+import subprocess
+import yaml
+from jarvis.jarvis_platform.registry import PlatformRegistry
+from jarvis.jarvis_tools.registry import ToolRegistry
+from jarvis.utils import OutputType, PrettyOutput, init_env, find_git_root
+from jarvis.agent import Agent
+import re
+
+class CodeReviewTool:
+    name = "code_review"
+    description = "Autonomous code review agent for code changes analysis"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "review_type": {
+                "type": "string",
+                "description": "Type of review: 'commit' for specific commit, 'current' for current changes, 'range' for commit range",
+                "enum": ["commit", "current", "range"],
+                "default": "current"
+            },
+            "commit_sha": {
+                "type": "string",
+                "description": "Target commit SHA to analyze (required for review_type='commit')"
+            },
+            "start_commit": {
+                "type": "string",
+                "description": "Start commit SHA (required for review_type='range')"
+            },
+            "end_commit": {
+                "type": "string",
+                "description": "End commit SHA (required for review_type='range')"
+            }
+        },
+        "required": []
+    }
+
+    def __init__(self):
+        init_env()
+        self.repo_root = find_git_root()
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            review_type = args.get("review_type", "current").strip()
+            
+            # Build git diff command based on review type
+            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 -"
+            
+            # 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": f"Failed to get diff: {str(e)}"
+                }
+
+            system_prompt = """You are an autonomous code review expert. Perform in-depth analysis following these guidelines:
+
+IMPORTANT:
+- Only analyze the provided diff content
+- Do NOT make assumptions about code not shown
+- Do NOT invent or imagine potential issues
+- Report ONLY issues that can be directly observed
+- If something is unclear, state it explicitly rather than making assumptions
+
+REVIEW FOCUS AREAS:
+1. Requirement Alignment:
+   - Verify implementation matches original requirements
+   - Check for missing functionality
+   - Identify over-implementation
+
+2. Code Quality:
+   - Code readability and structure
+   - Proper error handling
+   - Code duplication
+   - Adherence to style guides
+   - Meaningful variable/method names
+
+3. Security:
+   - Input validation
+   - Authentication/Authorization checks
+   - Sensitive data handling
+   - Potential injection vulnerabilities
+   - Secure communication practices
+
+4. Testing:
+   - Test coverage for new code
+   - Edge case handling
+   - Test readability and maintainability
+   - Missing test scenarios
+
+5. Performance:
+   - Algorithm efficiency
+   - Unnecessary resource consumption
+   - Proper caching mechanisms
+   - Database query optimization
+
+6. Maintainability:
+   - Documentation quality
+   - Logging and monitoring
+   - Configuration management
+   - Technical debt indicators
+
+7. Operational Considerations:
+   - Backward compatibility
+   - Migration script safety
+   - Environment-specific configurations
+   - Deployment impacts
+
+REVIEW PROCESS:
+1. Retrieve full commit context using git commands
+2. Analyze code changes line-by-line
+3. Cross-reference with project standards
+4. Verify test coverage adequacy
+5. Check documentation updates
+6. Generate prioritized findings
+
+OUTPUT REQUIREMENTS:
+- Categorize issues by severity (Critical/Major/Minor)
+- Reference specific code locations
+- Provide concrete examples from the diff
+- Suggest actionable improvements based on observed code
+- Highlight security risks clearly with evidence from the code
+- Separate technical debt from blockers
+- If certain aspects cannot be reviewed due to limited context, note this explicitly
+- Do not speculate about code not shown in the diff
+"""
+            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, format as yaml:
+<REPORT>
+- file: xxxx.py
+  location: [start_line_number, end_line_number]
+  description: # Only describe issues directly observable in the diff
+  severity: # Critical/Major/Minor based on concrete evidence
+  suggestion: # Specific, actionable improvements for the observed code
+</REPORT>""",
+                is_sub_agent=True,
+                tool_registry=tool_registry,
+                platform=PlatformRegistry().get_thinking_platform(),
+                auto_complete=True
+            )
+            result = agent.run(diff_output)
+            return {
+                "success": True,
+                "stdout": result,
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": {},
+                "stderr": f"Review failed: {str(e)}"
+            }
+        
+
+def extract_code_report(result: str) -> str:
+    sm = re.search(r"<REPORT>(.*?)</REPORT>", result, re.DOTALL)
+    if sm:
+        return sm.group(1)
+    return ""
+
+def main():
+    """CLI entry point"""
+    import argparse
+    
+    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()
+    
+    # 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'")
+    
+    tool = CodeReviewTool()
+    tool_args = {
+        "review_type": args.type
+    }
+    if args.commit:
+        tool_args["commit_sha"] = args.commit
+    if args.start_commit:
+        tool_args["start_commit"] = args.start_commit
+    if args.end_commit:
+        tool_args["end_commit"] = args.end_commit
+    
+    result = tool.execute(tool_args)
+    
+    if result["success"]:
+        PrettyOutput.section("Autonomous Review Result:", OutputType.SUCCESS)
+        report = extract_code_report(result["stdout"])
+        PrettyOutput.print(report, OutputType.SUCCESS, lang="yaml")
+        
+    else:
+        PrettyOutput.print(result["stderr"], OutputType.ERROR)
+
+if __name__ == "__main__":
+    main()

jarvis/jarvis_tools/create_code_agent.py

@@ -0,0 +1,115 @@
+import os
+from typing import Dict, Any
+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
+from jarvis.utils import OutputType, PrettyOutput, has_uncommitted_changes
+
+class CreateCodeAgentTool:
+    """Tool for managing the code development workflow."""
+    
+    name = "create_code_agent"
+    description = "Manage code development workflow including commit, development, and review"
+    parameters = {
+        "requirement": "The development requirement or task description"
+    }
+    
+    def _get_current_commit(self) -> str:
+        """Get current commit hash."""
+        return os.popen("git rev-parse HEAD").read().strip()
+    
+    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": ""
+                }
+            
+            # Step 1: Handle uncommitted changes
+            start_commit = None
+            if has_uncommitted_changes():
+                PrettyOutput.print("Found uncommitted changes, committing first...", 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 = self._get_current_commit()
+            
+            # Step 2: Development
+            PrettyOutput.print("Starting development...", OutputType.INFO)
+            agent = CodeAgent()
+            agent.run(requirement)
+            
+            # Get new commit hash after development
+            end_commit = self._get_current_commit()
+            
+            # Step 3: Code Review
+            PrettyOutput.print("Starting code review...", 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"""Development Summary:
+            
+Start Commit: {start_commit}
+End Commit: {end_commit}
+
+Requirement:
+{requirement}
+
+Code Review Result:
+{extract_code_report(review_result["stdout"])}
+"""
+            
+            return {
+                "success": True,
+                "stdout": summary,
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "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.ERROR)
+
+if __name__ == "__main__":
+    main()

jarvis/{tools → jarvis_tools}/create_sub_agent.py

@@ -2,7 +2,7 @@ from typing import Dict, Any
 
 
 from jarvis.agent import Agent, origin_agent_system_prompt
-from jarvis.tools.registry import ToolRegistry
+from jarvis.jarvis_tools.registry import ToolRegistry
 from jarvis.utils import OutputType, PrettyOutput