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

jarvis/tools/generate_tool.py

@@ -1,174 +0,0 @@
-import os
-from typing import Dict, Any
-from pathlib import Path
-from jarvis.models.registry import PlatformRegistry
-from jarvis.tools.registry import ToolRegistry
-from jarvis.utils import OutputType, PrettyOutput
-
-class ToolGeneratorTool:
-    name = "generate_tool"
-    description = "Generate new tool code and automatically register it to Jarvis, automatically expanding Jarvis's capabilities"
-    parameters = {
-        "type": "object",
-        "properties": {
-            "tool_name": {
-                "type": "string",
-                "description": "Name of the tool (in snake_case format)"
-            },
-            "class_name": {
-                "type": "string",
-                "description": "Name of the tool class (in PascalCase format)"
-            },
-            "description": {
-                "type": "string",
-                "description": "Description of the tool's functionality"
-            },
-            "parameters": {
-                "type": "object",
-                "description": "JSON Schema definition of tool parameters"
-            }
-        },
-        "required": ["tool_name", "class_name", "description", "parameters"]
-    }
-
-    def __init__(self):
-        """Initialize tool generator"""
-        # Set tool directory
-        self.tools_dir = Path.home() / '.jarvis/tools'
-        
-        # Ensure tool directory exists
-        self.tools_dir.mkdir(parents=True, exist_ok=True)
-
-    def _generate_tool_code(self, tool_name: str, class_name: str, description: str, parameters: Dict) -> str:
-        """Use large model to generate tool code"""
-        model = PlatformRegistry.get_global_platform_registry().get_codegen_platform()
-
-        prompt = f"""Please generate the code for a Python tool class, with the following requirements, and do not output any content except the code:
-
-1. Class name: {class_name}
-2. Tool name: {tool_name}
-3. Function description: {description}
-4. Parameter definition: {parameters}
-
-Strictly follow the following format to generate code (the parameters and return values of each function must be consistent with the example):
-
-```python
-from typing import Dict, Any, Protocol, Optional
-from jarvis.utils import OutputType, PrettyOutput
-from jarvis.models.registry import ModelRegistry
-
-class ExampleTool:
-    name = "example_tool"
-    description = "Example tool"
-    parameters = {{
-        "type": "object",
-        "properties": {{
-            "param1": {{"type": "string"}}
-        }},
-        "required": ["param1"]
-    }}
-
-    def __init__(self):
-        self.model = ModelRegistry.get_global_platform_registry().get_normal_platform()
-
-    def execute(self, args: Dict) -> Dict[str, Any]:
-        try:
-            # Validate parameter example
-            if "param1" not in args:
-                return {{"success": False, "error": "Missing required parameter: param1"}}
-            
-            # Record operation example
-            PrettyOutput.print(f"Processing parameter: {{args['param1']}}", OutputType.INFO)
-
-            # Use large model example
-            response = self.model.chat_until_success("prompt")
-            
-            # Implement specific functionality
-            result = "Processing result"
-            
-            return {{
-                "success": True,
-                "stdout": result,
-                "stderr": ""
-            }}
-        except Exception as e:
-            PrettyOutput.print(str(e), OutputType.ERROR)
-            return {{
-                "success": False,
-                "stdout": "",
-                "stderr": str(e)
-            }}
-```"""
-
-        # Call model to generate code
-        response = model.chat_until_success(prompt)
-
-        # Extract code block
-        code_start = response.find("```python")
-        code_end = response.find("```", code_start + 9)
-        
-        if code_start == -1 or code_end == -1:
-            # If code block marker not found, assume the entire response is code
-            return response
-        
-        # Extract code block content (remove ```python and ``` markers)
-        code = response[code_start + 9:code_end].strip()
-        return code
-
-    def execute(self, args: Dict) -> Dict[str, Any]:
-        """Generate tool code"""
-        try:
-            tool_name = args["tool_name"]
-            class_name = args["class_name"]
-            description = args["description"]
-            parameters = args["parameters"]
-
-            PrettyOutput.print(f"Start generating tool: {tool_name}", OutputType.INFO)
-
-            # Generate tool code
-            tool_code = self._generate_tool_code(
-                tool_name,
-                class_name,
-                description,
-                parameters
-            )
-
-            # Get tool file path
-            tool_file = self.tools_dir / f"{tool_name}.py"
-
-            # Write tool file
-            with open(tool_file, "w", encoding="utf-8") as f:
-                f.write(tool_code)
-
-            # Create or update __init__.py
-            init_file = self.tools_dir / "__init__.py"
-            if not init_file.exists():
-                with open(init_file, "w", encoding="utf-8") as f:
-                    f.write("# Jarvis Tools\n")
-
-            # Register tool
-            success = ToolRegistry.get_global_tool_registry().register_tool_by_file(str(tool_file))
-            if not success:
-                return {
-                    "success": False,
-                    "stdout": "",
-                    "stderr": "Tool generated successfully but registration failed"
-                }
-
-            return {
-                "success": True,
-                "stdout": f"Tool generated and registered to Jarvis\n"
-                         f"Tool directory: {self.tools_dir}\n"
-                         f"Tool name: {tool_name}\n"
-                         f"Tool description: {description}\n"
-                         f"Tool parameters: {parameters}",
-                "stderr": ""
-            }
-
-        except Exception as e:
-            PrettyOutput.print(str(e), OutputType.ERROR)
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"Failed to generate tool: {str(e)}"
-            }

jarvis/tools/thinker.py

@@ -1,151 +0,0 @@
-from typing import Dict, Any
-from jarvis.utils import OutputType, PrettyOutput, init_env
-from jarvis.models.registry import PlatformRegistry
-
-class ThinkerTool:
-    name = "thinker"
-    description = "Use chain of thought reasoning to analyze complex problems, suitable for scenarios that require multi-step reasoning, logical analysis, or creative thinking"
-    parameters = {
-        "type": "object",
-        "properties": {
-            "question": {
-                "type": "string",
-                "description": "The problem or task to analyze"
-            },
-            "context": {
-                "type": "string",
-                "description": "Context information or background knowledge related to the problem",
-                "default": ""
-            },
-            "goal": {
-                "type": "string",
-                "description": "The specific goal or result to achieve",
-                "default": ""
-            }
-        },
-        "required": ["question"]
-    }
-
-    def __init__(self):
-        """Initialize thinker tool"""
-        self.model = PlatformRegistry.get_global_platform_registry().get_thinking_platform()
-
-    def _generate_prompt(self, question: str, context: str, goal: str) -> str:
-        """Generate prompt
-        
-        Args:
-            question: problem
-            context: context
-            goal: goal
-            
-        Returns:
-            str: complete prompt
-        """
-        # 基础提示词
-        prompt = f"""You are a helpful assistant that is good at deep thinking and logical reasoning. Please help analyze the problem and provide a solution.
-
-Please think as follows:
-1. Carefully understand the problem and goal
-2. Conduct a systematic analysis and reasoning
-3. Consider multiple possible solutions
-4. Provide the best suggestions and specific action steps
-
-Problem:
-{question}
-"""
-        # 如果有目标，添加到提示词中
-        if goal:
-            prompt += f"""
-Goal:
-{goal}
-"""
-
-        # 如果有上下文，添加到提示词中
-        if context:
-            prompt += f"""
-Related context:
-{context}
-"""
-
-        prompt += "\nPlease start analyzing:"
-        return prompt
-
-    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-        """Execute thinking analysis
-        
-        Args:
-            args: dictionary containing parameters
-                - question: problem
-                - context: context (optional)
-                - goal: goal (optional)
-                
-        Returns:
-            Dict[str, Any]: execution result
-        """
-        try:
-            # Get parameters
-            question = args["question"]
-            context = args.get("context", "")
-            goal = args.get("goal", "")
-            
-            # 生成提示词
-            prompt = self._generate_prompt(question, context, goal)
-            
-            # Record start analysis
-            PrettyOutput.print(f"Start analyzing problem: {question}", OutputType.INFO)
-            if context:
-                PrettyOutput.print("Contains context information", OutputType.INFO)
-            if goal:
-                PrettyOutput.print(f"Goal: {goal}", OutputType.INFO)
-            
-            # 调用模型进行分析
-            response = self.model.chat_until_success(prompt)
-            
-            if not response:
-                return {
-                    "success": False,
-                    "stdout": "",
-                    "stderr": "Failed to obtain valid analysis results"
-                }
-                
-            return {
-                "success": True,
-                "stdout": response,
-                "stderr": ""
-            }
-            
-        except Exception as e:
-            PrettyOutput.print(f"Thinking analysis failed: {str(e)}", OutputType.ERROR)
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"Execution failed: {str(e)}"
-            }
-
-def main():
-    """Run tool directly from command line"""
-    import argparse
-
-    init_env()
-    
-    parser = argparse.ArgumentParser(description='Deep thinking analysis tool')
-    parser.add_argument('--question', required=True, help='The problem to analyze')
-    parser.add_argument('--context', help='Context information related to the problem')
-    parser.add_argument('--goal', help='Specific goal or result to achieve')
-    args = parser.parse_args()
-    
-    tool = ThinkerTool()
-    result = tool.execute({
-        "question": args.question,
-        "context": args.context,
-        "goal": args.goal
-    })
-    
-    if result["success"]:
-        PrettyOutput.print("\nAnalysis results:", OutputType.INFO)
-        PrettyOutput.print(result["stdout"], OutputType.INFO)
-    else:
-        PrettyOutput.print(result["stderr"], OutputType.ERROR)
-
-if __name__ == "__main__":
-    main() 

jarvis_ai_assistant-0.1.101.dist-info/RECORD

@@ -1,51 +0,0 @@
-jarvis/__init__.py,sha256=SEfhqUn2n4olRpFxLrz0OhFdsYO4-ww5CB_ZQwsLDyE,51
-jarvis/agent.py,sha256=dneYp0w25eeJpodcm59-r8V6fu7G_4MtCntvGNCLgBI,20868
-jarvis/utils.py,sha256=feUUqe8nA7MobPwVKH9ogMZrD1kH87-zeZxHvxWf83s,15807
-jarvis/jarvis_code_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jarvis/jarvis_code_agent/main.py,sha256=wZkYy_VmTg1iJBmQ6fD39hv2eC8FE6CVgtx7lxIUYHo,7050
-jarvis/jarvis_codebase/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jarvis/jarvis_codebase/main.py,sha256=rnA4rSyRmtVsKQ5HkQnNc57sZnT5sCBcmQFLWdzYJv8,36854
-jarvis/jarvis_coder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jarvis/jarvis_coder/file_select.py,sha256=BobNj5Kirr6jSwy59LOghC3o8Uff1CwTXNtlTO-idEo,8475
-jarvis/jarvis_coder/git_utils.py,sha256=R83iDYkDHIntQCd6p9g8Nne9oR5TVNhM-frd_2qR8Jo,5021
-jarvis/jarvis_coder/main.py,sha256=jicy9IN_94Dp8hDubOJX8t5h3vAmciAiS3v34WrvJZc,8469
-jarvis/jarvis_coder/patch_handler.py,sha256=NTNlVZ85uvVmtNNdwnQDPuCUYqEJJFL95ryZZauD2Dg,14876
-jarvis/jarvis_coder/plan_generator.py,sha256=x-FalwoRg79h-fvDgFQ8Cl-I8zJ7x2qcXsEUnRip9GA,6186
-jarvis/jarvis_platform/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jarvis/jarvis_platform/main.py,sha256=h08SaaIRBhqX8yIp_mG9vSKZYVBrBVfcC9gDK4A45RQ,4961
-jarvis/jarvis_rag/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jarvis/jarvis_rag/main.py,sha256=tp9skDCrassVTHRlbWJmA880CoF8OZTSFCiknoHRirU,33605
-jarvis/jarvis_smart_shell/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jarvis/jarvis_smart_shell/main.py,sha256=G03M39Bfwq8ieNZ8zoDbn0QeDs8Z9h2A0TxP8Hqf9GY,3951
-jarvis/models/__init__.py,sha256=mrOt67nselz_H1gX9wdAO4y2DY5WPXzABqJbr5Des8k,63
-jarvis/models/ai8.py,sha256=ZRNO3aRjmICRjCXl-_F9pTNQTY4j1tUd-WJoJpb9n4Y,11958
-jarvis/models/base.py,sha256=nQ-rsJL1Z-gMev3TPoY7tYdwxhCJY8LG6_gtJ-maiW0,2181
-jarvis/models/kimi.py,sha256=JSjSp_Hmmj_3bn0jxArE4lpG8jkQwhWx8qosjRMHdZE,16391
-jarvis/models/ollama.py,sha256=LzEA4kbkw1KflQ1T__hkmXu4--6xUPho2NTnj_ZQe6k,5761
-jarvis/models/openai.py,sha256=7AYKM0CKlI-tU5NtNdVaw5gobhgqSrXwGQLo5b2MJ7c,4404
-jarvis/models/oyi.py,sha256=iA8E5vzN9VIt-rlzpT5wmbyl7umVU1_y5yo_5gz3DXc,14534
-jarvis/models/registry.py,sha256=SM-jPu9TMommz0Fr_WrXpQE4X24QGyH39h0FwEQ-CWU,9448
-jarvis/tools/__init__.py,sha256=7Rqyj5hBAv5cWDVr5T9ZTZASO7ssBHeQNm2_4ZARdkA,72
-jarvis/tools/ask_user.py,sha256=cSxFn8cOZGQYHtfBtXlbdVQ7mlgC1JZCFBylparWShE,2102
-jarvis/tools/base.py,sha256=c0DMoDDPxmsqUYJR989zgUs7nIYRY6GWBrAdusIZKjc,656
-jarvis/tools/chdir.py,sha256=Nr16rLnrQ_eJH5E5HQ1a9o-UqAckKbWeboB3_SBVdVI,2926
-jarvis/tools/create_code_sub_agent.py,sha256=r5Ec3Ri9TGAj1M4c0Ur10I33aZ1i8dbtGK2DqqeebkQ,1718
-jarvis/tools/create_sub_agent.py,sha256=Nf_37sj8uQp1R1f7G1PkMRzwUFrHXj17WYLbusoDzO0,2807
-jarvis/tools/execute_code_modification.py,sha256=_LpzTiUfK7aprKzCrTDhBuu78miDcVyx7VV1Kh682DA,2508
-jarvis/tools/execute_shell.py,sha256=woJq-fivoXppp8rEhg46WVAImf6O89gHJnA7XOuYSM8,2568
-jarvis/tools/file_operation.py,sha256=Aq1EJA59AHR9XomxuxNiyLNon4p8w-Gk9iionl--odU,4082
-jarvis/tools/find_files.py,sha256=MTqijsXO6uFghb79pGaHWsa1NTgjP07p333BvUgMt5s,3696
-jarvis/tools/generate_tool.py,sha256=qhk73UFEPtMC-QfiWBUxnMhkgZMZM-esd0TdcFhWSmc,6181
-jarvis/tools/methodology.py,sha256=f6rF6vw-qaSIuJUrLbZdsLqzXMmAaw1aCwvJuezRX8k,5586
-jarvis/tools/rag.py,sha256=m_G4ct6SBLKKdUXfPkokK-qVlWeFCJ2B9J5IZhHXBXQ,4879
-jarvis/tools/read_webpage.py,sha256=AqE9Og_OzwFYIHZDTnCe_gB-szcUXbVZh-xZat4WgOU,2467
-jarvis/tools/registry.py,sha256=O-vzSaWr9VR3lrCIPF5NPl4V-zHHmz3H3l1_9ORyKsA,11057
-jarvis/tools/search.py,sha256=qf39Zm2Ad9-z4EyZKJrBCvZg1uqMeLuLQ9Zu8WB-TvI,9230
-jarvis/tools/select_code_files.py,sha256=hJwfh_CnyOn4QOBuNpKh9AD7-iH92mj7FP-6EifSH0w,1875
-jarvis/tools/thinker.py,sha256=-aWbjOjV3tGmYeIgAmyKVjd0teFs4ZK7mzPBA09R7hE,4847
-jarvis_ai_assistant-0.1.101.dist-info/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
-jarvis_ai_assistant-0.1.101.dist-info/METADATA,sha256=5szifjS1Gp4_XFLTOu5e8mATozRwUaNZM-9PokGDnAM,12783
-jarvis_ai_assistant-0.1.101.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-jarvis_ai_assistant-0.1.101.dist-info/entry_points.txt,sha256=x0jA_mYRc7hBVdLuOFQBYQjpXjf8NPrAn0C54DJ9t2I,387
-jarvis_ai_assistant-0.1.101.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
-jarvis_ai_assistant-0.1.101.dist-info/RECORD,,