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

jarvis/jarvis_smart_shell/main.py

@@ -13,7 +13,7 @@ from jarvis.utils import PrettyOutput, OutputType, init_env
 def execute_command(command: str) -> None:
     """Show command and allow user to edit, then execute, Ctrl+C to cancel"""
     try:
-        print("\nGenerated command (can be edited, press Enter to execute, Ctrl+C to cancel):")
+        print("Generated command (can be edited, press Enter to execute, Ctrl+C to cancel):")
         # Pre-fill input line
         readline.set_startup_hook(lambda: readline.insert_text(command))
         try:
@@ -21,7 +21,7 @@ def execute_command(command: str) -> None:
             if edited_command.strip():  # Ensure command is not empty
                 os.system(edited_command)
         except KeyboardInterrupt:
-            print("\nExecution cancelled")
+            print("Execution cancelled")
         finally:
             readline.set_startup_hook()  # Clear pre-filled
     except Exception as e:

jarvis/models/ai8.py

@@ -31,7 +31,9 @@ class AI8Model(BasePlatform):
         
         
         self.model_name = os.getenv("JARVIS_MODEL") or "deepseek-chat"
-
+        if self.model_name not in self.get_available_models():
+            PrettyOutput.print(f"Warning: The selected model {self.model_name} is not in the available list", OutputType.WARNING)
+        
 
     def set_model_name(self, model_name: str):
         """Set model name"""

jarvis/models/kimi.py

@@ -25,21 +25,24 @@ class KimiModel(BasePlatform):
         self.chat_id = ""
         self.api_key = os.getenv("KIMI_API_KEY")
         if not self.api_key:
-            PrettyOutput.print("\nNeed to set KIMI_API_KEY to use Jarvis. Please follow the steps below:", OutputType.INFO)
-            PrettyOutput.print("\n1. Get Kimi API Key:", OutputType.INFO)
-            PrettyOutput.print("   • Visit Kimi AI platform: https://kimi.moonshot.cn", OutputType.INFO)
-            PrettyOutput.print("   • Login to your account", OutputType.INFO)
-            PrettyOutput.print("   • Open browser developer tools (F12 or right-click -> Inspect)", OutputType.INFO)
-            PrettyOutput.print("   • Switch to the Network tab", OutputType.INFO)
-            PrettyOutput.print("   • Send any message", OutputType.INFO)
-            PrettyOutput.print("   • Find the Authorization header in the request", OutputType.INFO)
-            PrettyOutput.print("   • Copy the token value (remove the 'Bearer ' prefix)", OutputType.INFO)
-            PrettyOutput.print("\n2. Set environment variable:", OutputType.INFO)
-            PrettyOutput.print("   • Method 1: Create or edit ~/.jarvis/env file:", OutputType.INFO)
-            PrettyOutput.print("   echo 'KIMI_API_KEY=your_key_here' > ~/.jarvis/env", OutputType.INFO)
-            PrettyOutput.print("\n   • Method 2: Set environment variable directly:", OutputType.INFO)
-            PrettyOutput.print("   export KIMI_API_KEY=your_key_here", OutputType.INFO)
-            PrettyOutput.print("\nAfter setting, run Jarvis again.", OutputType.INFO)
+            message = (
+                "Need to set KIMI_API_KEY to use Jarvis. Please follow the steps below:\n"
+                "1. Get Kimi API Key:\n"
+                "   • Visit Kimi AI platform: https://kimi.moonshot.cn\n"
+                "   • Login to your account\n" 
+                "   • Open browser developer tools (F12 or right-click -> Inspect)\n"
+                "   • Switch to the Network tab\n"
+                "   • Send any message\n"
+                "   • Find the Authorization header in the request\n"
+                "   • Copy the token value (remove the 'Bearer ' prefix)\n"
+                "2. Set environment variable:\n"
+                "   • Method 1: Create or edit ~/.jarvis/env file:\n"
+                "   echo 'KIMI_API_KEY=your_key_here' > ~/.jarvis/env\n"
+                "   • Method 2: Set environment variable directly:\n"
+                "   export KIMI_API_KEY=your_key_here\n"
+                "After setting, run Jarvis again."
+            )
+            PrettyOutput.print(message, OutputType.INFO)
             PrettyOutput.print("KIMI_API_KEY is not set", OutputType.WARNING)
         self.auth_header = f"Bearer {self.api_key}"
         self.chat_id = ""
@@ -308,42 +311,45 @@ class KimiModel(BasePlatform):
 
             # 显示搜索结果摘要
             if search_results and not self.suppress_output:
-                PrettyOutput.print("\n搜索结果:", OutputType.PROGRESS)
+                output = ["搜索结果:"]
                 for result in search_results:
-                    PrettyOutput.print(f"- {result['title']}", OutputType.PROGRESS)
+                    output.append(f"- {result['title']}")
                     if result['date']:
-                        PrettyOutput.print(f"  日期: {result['date']}", OutputType.PROGRESS)
-                    PrettyOutput.print(f"  来源: {result['site_name']}", OutputType.PROGRESS)
+                        output.append(f"  日期: {result['date']}")
+                    output.append(f"  来源: {result['site_name']}")
                     if result['snippet']:
-                        PrettyOutput.print(f"  摘要: {result['snippet']}", OutputType.PROGRESS)
-                    PrettyOutput.print(f"  链接: {result['url']}", OutputType.PROGRESS)
-                    PrettyOutput.print("", OutputType.PROGRESS)
+                        output.append(f"  摘要: {result['snippet']}")
+                    output.append(f"  链接: {result['url']}")
+                    output.append("")
+                PrettyOutput.print("\n".join(output), OutputType.PROGRESS)
                         
             # 显示引用来源
             if ref_sources and not self.suppress_output:
-                PrettyOutput.print("\n引用来源:", OutputType.PROGRESS)
+                output = ["引用来源:"]
                 for source in ref_sources:
-                    PrettyOutput.print(f"- [{source['ref_id']}] {source['title']} ({source['source']})", OutputType.PROGRESS)
-                    PrettyOutput.print(f"  链接: {source['url']}", OutputType.PROGRESS)
+                    output.append(f"- [{source['ref_id']}] {source['title']} ({source['source']})")
+                    output.append(f"  链接: {source['url']}")
                     if source['abstract']:
-                        PrettyOutput.print(f"  摘要: {source['abstract']}", OutputType.PROGRESS)
+                        output.append(f"  摘要: {source['abstract']}")
                     
                     # 显示相关段落
                     if source['rag_segments']:
-                        PrettyOutput.print("  相关段落:", OutputType.PROGRESS)
+                        output.append("  相关段落:")
                         for segment in source['rag_segments']:
                             text = segment.get('text', '').replace('\n', ' ').strip()
                             if text:
-                                PrettyOutput.print(f"    - {text}", OutputType.PROGRESS)
+                                output.append(f"    - {text}")
                     
                     # 显示原文引用
                     origin = source['origin']
                     if origin:
                         text = origin.get('text', '')
                         if text:
-                            PrettyOutput.print(f"  原文: {text}", OutputType.PROGRESS)
+                            output.append(f"  原文: {text}")
                     
-                    PrettyOutput.print("", OutputType.PROGRESS)
+                    output.append("")
+
+                PrettyOutput.print("\n".join(output), OutputType.PROGRESS)
 
             PrettyOutput.print(full_response, OutputType.RESULT)
             

jarvis/models/ollama.py

@@ -25,18 +25,24 @@ class OllamaPlatform(BasePlatform):
             available_models = [model["name"] for model in response.json().get("models", [])]
             
             if not available_models:
-                PrettyOutput.print("\nNeed to download Ollama model first to use:", OutputType.INFO)
-                PrettyOutput.print("1. Install Ollama: https://ollama.ai", OutputType.INFO)
-                PrettyOutput.print("2. Download model:", OutputType.INFO)
-                PrettyOutput.print(f"   ollama pull {self.model_name}", OutputType.INFO)
+                message = (
+                    "Need to download Ollama model first to use:\n"
+                    "1. Install Ollama: https://ollama.ai\n"
+                    "2. Download model:\n"
+                    f"   ollama pull {self.model_name}"
+                )
+                PrettyOutput.print(message, OutputType.INFO)
                 PrettyOutput.print("Ollama has no available models", OutputType.WARNING)
                 
         except requests.exceptions.ConnectionError:
-            PrettyOutput.print("\nOllama service is not started or cannot be connected", OutputType.WARNING)
-            PrettyOutput.print("Please ensure that you have:", OutputType.INFO)
-            PrettyOutput.print("1. Installed Ollama: https://ollama.ai", OutputType.INFO)
-            PrettyOutput.print("2. Started Ollama service", OutputType.INFO)
-            PrettyOutput.print("3. Service address configured correctly (default: http://localhost:11434)", OutputType.INFO)
+            message = (
+                "Ollama service is not started or cannot be connected\n"
+                "Please ensure that you have:\n"
+                "1. Installed Ollama: https://ollama.ai\n"
+                "2. Started Ollama service\n"
+                "3. Service address configured correctly (default: http://localhost:11434)"
+            )
+            PrettyOutput.print(message, OutputType.WARNING)
             
             
         self.messages = []
@@ -136,10 +142,10 @@ if __name__ == "__main__":
         ollama = OllamaPlatform()
         while True:
             try:
-                message = get_single_line_input("\nInput question (Ctrl+C to exit)")
+                message = get_single_line_input("Input question (Ctrl+C to exit)")
                 ollama.chat_until_success(message)
             except KeyboardInterrupt:
-                print("\nGoodbye!")
+                print("Goodbye!")
                 break
     except Exception as e:
         PrettyOutput.print(f"Program exited with an exception: {str(e)}", OutputType.ERROR)

jarvis/models/openai.py

@@ -19,18 +19,21 @@ class OpenAIModel(BasePlatform):
         self.system_message = ""
         self.api_key = os.getenv("OPENAI_API_KEY")
         if not self.api_key:
-            PrettyOutput.print("\nNeed to set the following environment variables to use OpenAI model:", OutputType.INFO)
-            PrettyOutput.print("  • OPENAI_API_KEY: API key", OutputType.INFO)
-            PrettyOutput.print("  • OPENAI_API_BASE: (optional) API base address, default using https://api.openai.com/v1", OutputType.INFO)
-            PrettyOutput.print("\nYou can set them in the following ways:", OutputType.INFO)
-            PrettyOutput.print("1. Create or edit ~/.jarvis/env file:", OutputType.INFO)
-            PrettyOutput.print("   OPENAI_API_KEY=your_api_key", OutputType.INFO)
-            PrettyOutput.print("   OPENAI_API_BASE=your_api_base", OutputType.INFO)
-            PrettyOutput.print("   OPENAI_MODEL_NAME=your_model_name", OutputType.INFO)
-            PrettyOutput.print("\n2. Or set the environment variables directly:", OutputType.INFO)
-            PrettyOutput.print("   export OPENAI_API_KEY=your_api_key", OutputType.INFO)
-            PrettyOutput.print("   export OPENAI_API_BASE=your_api_base", OutputType.INFO)
-            PrettyOutput.print("   export OPENAI_MODEL_NAME=your_model_name", OutputType.INFO)
+            message = (
+                "Need to set the following environment variables to use OpenAI model:\n"
+                "  • OPENAI_API_KEY: API key\n" 
+                "  • OPENAI_API_BASE: (optional) API base address, default using https://api.openai.com/v1\n"
+                "You can set them in the following ways:\n"
+                "1. Create or edit ~/.jarvis/env file:\n"
+                "   OPENAI_API_KEY=your_api_key\n"
+                "   OPENAI_API_BASE=your_api_base\n" 
+                "   OPENAI_MODEL_NAME=your_model_name\n"
+                "2. Or set the environment variables directly:\n"
+                "   export OPENAI_API_KEY=your_api_key\n"
+                "   export OPENAI_API_BASE=your_api_base\n"
+                "   export OPENAI_MODEL_NAME=your_model_name"
+            )
+            PrettyOutput.print(message, OutputType.INFO)
             PrettyOutput.print("OPENAI_API_KEY is not set", OutputType.WARNING)
             
         self.base_url = os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1")

jarvis/models/oyi.py

@@ -32,6 +32,9 @@ class OyiModel(BasePlatform):
             PrettyOutput.print("OYI_API_KEY is not set", OutputType.WARNING)
         
         self.model_name = os.getenv("JARVIS_MODEL") or "deepseek-chat"
+        if self.model_name not in [m.split()[0] for m in self.get_available_models()]:
+            PrettyOutput.print(f"Warning: The selected model {self.model_name} is not in the available list", OutputType.WARNING)
+        
 
     def set_model_name(self, model_name: str):
         """Set model name"""
@@ -63,7 +66,7 @@ class OyiModel(BasePlatform):
                     "requestMsgCount": 65536,
                     "temperature": 0.8,
                     "speechVoice": "Alloy",
-                    "max_tokens": get_max_context_length(),
+                    "max_tokens": 8192,
                     "chatPluginIds": []
                 })
             }
@@ -168,19 +171,33 @@ class OyiModel(BasePlatform):
             # 获取响应内容
             response = requests.post(
                 f"{self.BASE_URL}/chatapi/chat/message/{message_id}",
-                headers=headers
+                headers=headers,
+                stream=True
             )
             
             if response.status_code == 200:
-                if not self.suppress_output:
-                    PrettyOutput.print(response.text, OutputType.SYSTEM)
-                self.messages.append({"role": "assistant", "content": response.text})
-                return response.text
+                full_response = ""
+                bin = b""
+                for chunk in response.iter_content(decode_unicode=True):
+                    if chunk:
+                        bin += chunk
+                        try:
+                            text = bin.decode('utf-8')
+                        except UnicodeDecodeError:
+                            continue
+                        if not self.suppress_output:
+                            PrettyOutput.print_stream(text)
+                        full_response += text
+                        bin = b""
+
+                PrettyOutput.print_stream_end()
+                
+                self.messages.append({"role": "assistant", "content": full_response})
+                return full_response
             else:
                 error_msg = f"Get response failed: {response.status_code}"
                 PrettyOutput.print(error_msg, OutputType.ERROR)
                 raise Exception(error_msg)
-            
         except Exception as e:
             PrettyOutput.print(f"Chat failed: {str(e)}", OutputType.ERROR)
             raise e

jarvis/models/registry.py

@@ -211,31 +211,7 @@ class PlatformRegistry:
         except Exception as e:
             PrettyOutput.print(f"Create platform failed: {str(e)}", OutputType.ERROR)
             return None
-            
-    def use_platforms(self, platform_names: List[str]):
-        """Restrict available platforms to the specified list
-        
-        Args:
-            platform_names: List of platform names to use
-        """
-        self.platforms = {
-            name: cls 
-            for name, cls in self.platforms.items()
-            if name in platform_names
-        }
 
-    def dont_use_platforms(self, platform_names: List[str]):
-        """Restrict available platforms by excluding the specified list
-        
-        Args:
-            platform_names: List of platform names to exclude
-        """
-        self.platforms = {
-            name: cls 
-            for name, cls in self.platforms.items()
-            if name not in platform_names
-        }
     def get_available_platforms(self) -> List[str]:
         """Get available platform list"""
-        return list(self.platforms.keys()) 
-    
+        return list(self.platforms.keys())

jarvis/tools/__init__.py

@@ -1,6 +0,0 @@
-from .registry import ToolRegistry
-
-__all__ = [
-    'ToolRegistry',
-] 
-

jarvis/tools/ask_codebase.py

@@ -0,0 +1,99 @@
+from typing import Dict, Any
+from jarvis.utils import OutputType, PrettyOutput, dont_use_local_model, find_git_root
+from jarvis.jarvis_codebase.main import CodeBase
+
+class AskCodebaseTool:
+    """Tool for intelligent codebase querying and analysis using CodeBase"""
+    
+    name = "ask_codebase"
+    description = "Ask questions about the codebase and get detailed analysis"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "question": {
+                "type": "string",
+                "description": "Question about the codebase"
+            },
+            "top_k": {
+                "type": "integer",
+                "description": "Number of most relevant files to analyze (optional)",
+                "default": 20
+            }
+        },
+        "required": ["question"]
+    }
+
+    @staticmethod
+    def check() -> bool:
+        return not dont_use_local_model()
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute codebase analysis using CodeBase
+        
+        Args:
+            args: Dictionary containing:
+                - question: The question to answer
+                - top_k: Optional number of files to analyze
+                
+        Returns:
+            Dict containing:
+                - success: Boolean indicating success
+                - stdout: Analysis result
+                - stderr: Error message if any
+        """
+        try:
+            question = args["question"]
+            top_k = args.get("top_k", 20)
+
+            PrettyOutput.print(f"Analyzing codebase for question: {question}", OutputType.INFO)
+
+            # Create new CodeBase instance
+            git_root = find_git_root()
+            codebase = CodeBase(git_root)
+
+            # Use ask_codebase method
+            response = codebase.ask_codebase(question, top_k)
+
+            return {
+                "success": True,
+                "stdout": response,
+                "stderr": ""
+            }
+
+        except Exception as e:
+            error_msg = f"Failed to analyze codebase: {str(e)}"
+            PrettyOutput.print(error_msg, OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": error_msg
+            }
+
+
+def main():
+    """Command line interface for the tool"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Ask questions about the codebase')
+    parser.add_argument('question', help='Question about the codebase')
+    parser.add_argument('--top-k', type=int, help='Number of files to analyze', default=20)
+    
+    args = parser.parse_args()
+    
+    tool = AskCodebaseTool()
+    result = tool.execute({
+        "question": args.question,
+        "top_k": args.top_k
+    })
+    
+    if result["success"]:
+        print(result["stdout"])
+    else:
+        PrettyOutput.print(result["stderr"], OutputType.ERROR)
+        return 1
+        
+    return 0
+
+
+if __name__ == "__main__":
+    main()

jarvis/tools/ask_user.py

@@ -30,19 +30,11 @@ class AskUserTool:
             question = args["question"]
             
             # Display the question
-            PrettyOutput.print("\nQuestion:", OutputType.SYSTEM)
-            PrettyOutput.print(question, OutputType.SYSTEM)
+            PrettyOutput.print(f"Question: {question}", OutputType.SYSTEM)
             
             # Get user input
             user_response = get_multiline_input("Please enter your answer (input empty line to end)")
             
-            if user_response == "__interrupt__":
-                return {
-                    "success": False,
-                    "stdout": "",
-                    "stderr": "User canceled input"
-                }
-            
             return {
                 "success": True,
                 "stdout": user_response,

jarvis/tools/chdir.py

@@ -31,7 +31,7 @@ class ChdirTool:
             - error: 失败时的错误信息
         """
         try:
-            path = os.path.expanduser(args["path"])  # 展开 ~ 等路径
+            path = os.path.expanduser(args["path"].strip())  # 展开 ~ 等路径
             path = os.path.abspath(path)  # 转换为绝对路径
             
             # 检查目录是否存在

jarvis/tools/code_review.py

@@ -0,0 +1,163 @@
+from typing import Dict, Any
+import subprocess
+import yaml
+from jarvis.models.registry import PlatformRegistry
+from jarvis.tools.registry import ToolRegistry
+from jarvis.utils import OutputType, PrettyOutput, init_env, find_git_root
+from jarvis.agent import Agent
+
+class CodeReviewTool:
+    name = "code_review"
+    description = "Autonomous code review agent for commit analysis"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "commit_sha": {
+                "type": "string",
+                "description": "Target commit SHA to analyze"
+            },
+            "requirement_desc": {
+                "type": "string",
+                "description": "Development goal to verify"
+            }
+        },
+        "required": ["commit_sha", "requirement_desc"]
+    }
+
+    def __init__(self):
+        init_env()
+        self.repo_root = find_git_root()
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            commit_sha = args["commit_sha"].strip()
+            requirement = args["requirement_desc"].strip()
+            
+            system_prompt = """You are an autonomous code review expert. Perform in-depth analysis following these guidelines:
+
+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
+- Suggest actionable improvements
+- Highlight security risks clearly
+- Separate technical debt from blockers"""
+
+            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: 
+  severity: 
+  suggestion: 
+</REPORT>
+
+Please describe in concise bullet points, highlighting important information.
+"""
+
+            tool_registry = ToolRegistry()
+            tool_registry.use_tools(["execute_shell", "read_code", "ask_user", "ask_codebase", "find_in_codebase", "create_ctags_agent"])
+            tool_registry.dont_use_tools(["code_review"])
+
+            review_agent = Agent(
+                name="Code Review Agent",
+                platform=PlatformRegistry().get_thinking_platform(),
+                system_prompt=system_prompt,
+                is_sub_agent=True,
+                tool_registry=tool_registry,
+                summary_prompt=summary_prompt,
+                auto_complete=True
+            )
+            
+            result = review_agent.run(
+                f"Analyze commit {commit_sha} for requirement: {requirement}"
+            )
+
+            return {
+                "success": True,
+                "stdout": {"report": result},
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": {},
+                "stderr": f"Review failed: {str(e)}"
+            }
+
+def main():
+    """CLI entry point"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Autonomous code review tool')
+    parser.add_argument('--commit', required=True)
+    parser.add_argument('--requirement', required=True)
+    args = parser.parse_args()
+    
+    tool = CodeReviewTool()
+    result = tool.execute({
+        "commit_sha": args.commit,
+        "requirement_desc": args.requirement
+    })
+    
+    if result["success"]:
+        PrettyOutput.print("Autonomous Review Result:", OutputType.INFO)
+        print(yaml.dump(result["stdout"], allow_unicode=True))
+    else:
+        PrettyOutput.print(result["stderr"], OutputType.ERROR)
+
+if __name__ == "__main__":
+    main()