jarvis-ai-assistant 0.1.104__py3-none-any.whl → 0.1.106__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():

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):

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_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}/code_review.py

@@ -1,8 +1,8 @@
 from typing import Dict, Any, List
 import subprocess
 import yaml
-from jarvis.models.registry import PlatformRegistry
-from jarvis.tools.registry import ToolRegistry
+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
@@ -15,13 +15,21 @@ class CodeReviewTool:
         "properties": {
             "review_type": {
                 "type": "string",
-                "description": "Type of review: 'commit' for specific commit, 'current' for current changes",
-                "enum": ["commit", "current"],
+                "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": []
@@ -45,6 +53,16 @@ class CodeReviewTool:
                     }
                 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 -"
             
@@ -169,7 +187,7 @@ OUTPUT REQUIREMENTS:
             }
         
 
-def _extract_code_report(result: str) -> str:
+def extract_code_report(result: str) -> str:
     sm = re.search(r"<REPORT>(.*?)</REPORT>", result, re.DOTALL)
     if sm:
         return sm.group(1)
@@ -180,14 +198,18 @@ def main():
     import argparse
     
     parser = argparse.ArgumentParser(description='Autonomous code review tool')
-    parser.add_argument('--type', choices=['commit', 'current'], default='current',
-                      help='Type of review: commit or current changes')
+    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 = {
@@ -195,12 +217,16 @@ def main():
     }
     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"])
+        report = extract_code_report(result["stdout"])
         PrettyOutput.print(report, OutputType.SUCCESS, lang="yaml")
         
     else:

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
 
 

jarvis/jarvis_tools/deep_thinking.py

@@ -0,0 +1,160 @@
+import os
+from typing import Dict, Any
+from jarvis.jarvis_platform.registry import PlatformRegistry
+from jarvis.utils import OutputType, PrettyOutput
+
+class DeepThinkingTool:
+    """Tool for deep thinking about user requirements using thinking platform."""
+    
+    name = "deep_thinking"
+    description = "Analyze and think deeply about user requirements"
+    parameters = {
+        "requirement": "The requirement or question to think about",
+        "mode": {
+            "type": "string",
+            "description": "Thinking mode: analysis/solution/critique",
+            "enum": ["analysis", "solution", "critique"],
+            "default": "analysis"
+        }
+    }
+    
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            requirement = args.get("requirement", "")
+            mode = args.get("mode", "analysis")
+            
+            if not requirement:
+                return {
+                    "success": False,
+                    "stderr": "Requirement must be provided",
+                    "stdout": ""
+                }
+            
+            # Get thinking platform
+            platform = PlatformRegistry().get_thinking_platform()
+            
+            # Build prompt based on mode
+            if mode == "analysis":
+                prompt = f"""Please analyze this requirement deeply. Consider:
+
+1. Core Objectives:
+   - What is the fundamental goal?
+   - What are the key requirements?
+   - What are the implicit needs?
+
+2. Scope Analysis:
+   - What is included/excluded?
+   - What are the boundaries?
+   - What are potential edge cases?
+
+3. Challenges:
+   - What are the technical challenges?
+   - What are potential risks?
+   - What needs special attention?
+
+4. Dependencies:
+   - What are the prerequisites?
+   - What systems will be affected?
+   - What integrations are needed?
+
+Requirement to analyze:
+{requirement}
+
+Please provide a structured analysis."""
+
+            elif mode == "solution":
+                prompt = f"""Please think deeply about potential solutions. Consider:
+
+1. Solution Approaches:
+   - What are possible approaches?
+   - What are the pros/cons of each?
+   - What is the recommended approach?
+
+2. Implementation Strategy:
+   - How should this be implemented?
+   - What are the key steps?
+   - What is the suggested order?
+
+3. Technical Considerations:
+   - What technologies should be used?
+   - What patterns would work best?
+   - What should be avoided?
+
+4. Risk Mitigation:
+   - How to handle potential issues?
+   - What safeguards are needed?
+   - What should be tested carefully?
+
+Requirement to solve:
+{requirement}
+
+Please provide a structured solution plan."""
+
+            else:  # critique
+                prompt = f"""Please critique this requirement carefully. Consider:
+
+1. Clarity:
+   - Is it clearly defined?
+   - Are there ambiguities?
+   - What needs clarification?
+
+2. Completeness:
+   - Are all aspects covered?
+   - What might be missing?
+   - Are edge cases considered?
+
+3. Feasibility:
+   - Is it technically feasible?
+   - Are there resource constraints?
+   - What are potential blockers?
+
+4. Improvements:
+   - How could it be better?
+   - What should be added/removed?
+   - What alternatives exist?
+
+Requirement to critique:
+{requirement}
+
+Please provide a structured critique."""
+
+            # Get thinking result
+            result = platform.chat_until_success(prompt)
+            
+            return {
+                "success": True,
+                "stdout": result,
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "stderr": f"Thinking failed: {str(e)}",
+                "stdout": ""
+            }
+
+def main():
+    """CLI entry point"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Deep thinking tool')
+    parser.add_argument('requirement', help='Requirement to think about')
+    parser.add_argument('--mode', choices=['analysis', 'solution', 'critique'],
+                      default='analysis', help='Thinking mode')
+    
+    args = parser.parse_args()
+    
+    tool = DeepThinkingTool()
+    result = tool.execute({
+        "requirement": args.requirement,
+        "mode": args.mode
+    })
+    
+    if result["success"]:
+        PrettyOutput.print(result["stdout"], OutputType.SUCCESS)
+    else:
+        PrettyOutput.print(result["stderr"], OutputType.ERROR)
+
+if __name__ == "__main__":
+    main()