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

jarvis/tools/find_files.py

@@ -1,119 +0,0 @@
-from typing import Dict, Any
-
-from jarvis.agent import Agent
-from jarvis.tools.registry import ToolRegistry
-from jarvis.utils import OutputType, PrettyOutput
-
-find_files_system_prompt = """You are a Find Files Agent specialized in searching and identifying relevant code files in a codebase. Your task is to find files that are most likely related to the given requirements or problems.
-
-SEARCH WORKFLOW:
-1. Understand Search Requirements
-   - Analyze the search query thoroughly
-   - Identify key technical terms and concepts
-   - Break down complex requirements into searchable terms
-
-2. Execute Search Strategy
-   - Use shell commands to search systematically:
-     * Search for key terms:
-       <TOOL_CALL>
-       name: execute_shell
-       arguments:
-           command: grep -r "pattern" .
-       </TOOL_CALL>
-     * Find files by name patterns:
-       <TOOL_CALL>
-       name: execute_shell
-       arguments:
-           command: find . -name "pattern"
-       </TOOL_CALL>
-     * Examine file contents:
-       <TOOL_CALL>
-       name: execute_shell
-       arguments:
-           command: grep -A 5 -B 5 "pattern" file.py
-       </TOOL_CALL>
-
-3. Analyze Results
-   - Review each potential file
-   - Check file relevance
-   - Examine file relationships
-   - Consider file dependencies
-
-4. Generate File List
-   - List all relevant files
-   - Sort by relevance
-   - Include brief explanation for each file
-   - Format output as YAML
-
-OUTPUT FORMAT:
-files:
-  - path: path/to/file1
-    relevance: "Brief explanation of why this file is relevant"
-  - path: path/to/file2
-    relevance: "Brief explanation of why this file is relevant"
-
-SEARCH BEST PRACTICES:
-- Use multiple search terms
-- Consider file naming conventions
-- Check both file names and contents
-- Look for related files (imports, dependencies)
-- Use grep with context (-A, -B options)
-- Search in specific directories when appropriate
-- Exclude irrelevant directories (like .git, __pycache__)
-
-IMPORTANT:
-1. Focus on finding the most relevant files
-2. Avoid listing irrelevant files
-3. Explain relevance clearly but concisely
-4. Consider both direct and indirect relevance
-5. Use file content to confirm relevance
-"""
-
-class FindFilesTool:
-    name = "find_files"
-    description = "Search and identify relevant code files in the codebase based on requirements or problems"
-    parameters = {
-        "type": "object",
-        "properties": {
-            "query": {
-                "type": "string",
-                "description": "The search query or requirement description"
-            }
-        },
-        "required": ["query"]
-    }
-
-    def execute(self, args: Dict) -> Dict[str, Any]:
-        """Execute file search task"""
-        try:
-            query = args["query"]
-
-            PrettyOutput.print(f"Creating Find Files agent to search for: {query}", OutputType.INFO)
-
-            tool_registry = ToolRegistry()
-            tool_registry.use_tools(["ask_user", "execute_shell", "file_operation"])
-
-            # Create find files agent
-            find_agent = Agent(
-                system_prompt=find_files_system_prompt,
-                name="Find Files Agent",
-                is_sub_agent=True,
-                tool_registry=tool_registry
-            )
-
-            # Execute search
-            result = find_agent.run(query)
-
-            return {
-                "success": True,
-                "stdout": result,
-                "stderr": ""
-            }
-
-        except Exception as e:
-            PrettyOutput.print(str(e), OutputType.ERROR)
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"Failed to execute file search: {str(e)}"
-            }

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.102.dist-info/RECORD

@@ -1,46 +0,0 @@
-jarvis/__init__.py,sha256=Gi4_qXeI7FimxfYp4-9b34vvlAoyygoTuOD13Jxxb4U,51
-jarvis/agent.py,sha256=sQdOpttUvXYM1jFNjlhXNrNbpFaKAzt5et2VvB2XluU,19899
-jarvis/utils.py,sha256=Y_p-nVwQ43WDuTFyrE7wPNMHlrJ2rZwfTc4Gnd1cjyg,11306
-jarvis/jarvis_code_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jarvis/jarvis_code_agent/main.py,sha256=jd9r6lpUF4kWeOvye8CjKLhAQm5H_Lq1m3xOXq_vDzQ,6939
-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/patch_handler.py,sha256=NTNlVZ85uvVmtNNdwnQDPuCUYqEJJFL95ryZZauD2Dg,14876
-jarvis/jarvis_github/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jarvis/jarvis_github/main.py,sha256=yUvtNU9BqUSGbb4UxbiNcLcqzvNKEP0MAv_N-IaYunk,8671
-jarvis/jarvis_platform/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jarvis/jarvis_platform/main.py,sha256=h08SaaIRBhqX8yIp_mG9vSKZYVBrBVfcC9gDK4A45RQ,4961
-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=vEeORfmRzuIT9fQR4vuE4OIOga0ie3syUxQsD822q2w,11793
-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=BFpf0RTIipwITAEOyVD2sG_3VKF4Q1FL2HWLrFirh0g,14344
-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/read_webpage.py,sha256=AqE9Og_OzwFYIHZDTnCe_gB-szcUXbVZh-xZat4WgOU,2467
-jarvis/tools/registry.py,sha256=A0oF4LmUM2prGTTOiht-y9rGETH90brGhnGC5gDtLvU,11384
-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.102.dist-info/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
-jarvis_ai_assistant-0.1.102.dist-info/METADATA,sha256=nrb2u09-wYl8oXVQVdv_fboHGDahaHPXWmz-G9YzShw,11473
-jarvis_ai_assistant-0.1.102.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-jarvis_ai_assistant-0.1.102.dist-info/entry_points.txt,sha256=644e3D9ej4jGcfhYDuUjdU3VNel0H7VkZKGaRhHvvJI,250
-jarvis_ai_assistant-0.1.102.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
-jarvis_ai_assistant-0.1.102.dist-info/RECORD,,

jarvis_ai_assistant-0.1.102.dist-info/entry_points.txt

@@ -1,6 +0,0 @@
-[console_scripts]
-jarvis = jarvis.agent:main
-jarvis-code-agent = jarvis.jarvis_code_agent.main:main
-jarvis-platform = jarvis.jarvis_platform.main:main
-jarvis-smart-shell = jarvis.jarvis_smart_shell.main:main
-jss = jarvis.jarvis_smart_shell.main:main