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

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

jarvis/jarvis_tools/deep_thinking_agent.py

@@ -0,0 +1,146 @@
+import os
+from typing import Dict, Any
+from jarvis.agent import Agent
+from jarvis.jarvis_platform.registry import PlatformRegistry
+from jarvis.jarvis_tools.registry import ToolRegistry
+from jarvis.utils import OutputType, PrettyOutput
+
+class DeepThinkingAgentTool:
+    """Tool for deep thinking using an agent with thinking platform."""
+    
+    name = "deep_thinking_agent"
+    description = "Use an agent to think deeply about problems and solutions"
+    parameters = {
+        "question": "The question or problem to think about"
+    }
+    
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            question = args.get("question", "")
+            if not question:
+                return {
+                    "success": False,
+                    "stderr": "Question must be provided",
+                    "stdout": ""
+                }
+            
+            # Initialize tool registry
+            tool_registry = ToolRegistry()
+            tool_registry.dont_use_tools([
+                "deep_thinking_agent"
+            ])
+            
+            # Define system prompt for thinking agent
+            system_prompt = """You are a deep thinking agent that carefully analyzes problems and proposes solutions.
+
+THINKING PROCESS:
+1. Initial Analysis
+   ```
+   Thought: Let me first understand the core problem...
+   Action: Use deep_thinking with mode=analysis
+   Observation: The analysis shows...
+   
+   Thought: I need more information about...
+   Action: Use appropriate tool (search/ask_user/ask_codebase)
+   Observation: Found that...
+   ```
+
+2. Solution Exploration
+   ```
+   Thought: Let me explore possible solutions...
+   Action: Use deep_thinking with mode=solution
+   Observation: The potential solutions are...
+   
+   Thought: I should validate these approaches...
+   Action: Use appropriate tool to verify
+   Observation: Verification shows...
+   ```
+
+3. Critical Review
+   ```
+   Thought: Let me critique the proposed solution...
+   Action: Use deep_thinking with mode=critique
+   Observation: The critique reveals...
+   
+   Thought: These points need addressing...
+   Action: Revise solution based on critique
+   Observation: The improved solution...
+   ```
+
+4. Final Recommendation
+   ```
+   Thought: Synthesize all findings...
+   Action: Compile final recommendation
+   Output: Detailed solution with rationale
+   ```
+
+GUIDELINES:
+- Use deep_thinking tool for structured analysis
+- Validate assumptions with search/ask_user
+- Consider multiple perspectives
+- Provide evidence for conclusions
+- Be thorough but practical
+- Focus on actionable recommendations
+
+Please proceed with the analysis and provide a comprehensive response."""
+            
+            # Create agent with thinking platform
+            agent = Agent(
+                system_prompt=system_prompt,
+                name="DeepThinkingAgent",
+                tool_registry=tool_registry,
+                platform=PlatformRegistry().get_thinking_platform(),
+                auto_complete=True,
+                is_sub_agent=True,
+                summary_prompt="""Please provide a structured summary of your thinking process and conclusions:
+
+<THINKING_SUMMARY>
+Analysis:
+[Key findings from analysis]
+
+Solutions:
+[Proposed solutions and rationale]
+
+Critique:
+[Critical considerations]
+
+Recommendation:
+[Final recommendation with justification]
+</THINKING_SUMMARY>"""
+            )
+            
+            # Run agent
+            result = agent.run(question)
+            
+            return {
+                "success": True,
+                "stdout": result,
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "stderr": f"Deep thinking failed: {str(e)}",
+                "stdout": ""
+            }
+
+def main():
+    """CLI entry point"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Deep thinking agent')
+    parser.add_argument('question', help='Question or problem to think about')
+    
+    args = parser.parse_args()
+    
+    tool = DeepThinkingAgentTool()
+    result = tool.execute({"question": args.question})
+    
+    if result["success"]:
+        PrettyOutput.print(result["stdout"], OutputType.SUCCESS)
+    else:
+        PrettyOutput.print(result["stderr"], OutputType.ERROR)
+
+if __name__ == "__main__":
+    main()

jarvis/{tools → jarvis_tools}/git_commiter.py

@@ -4,8 +4,8 @@ from typing import Dict, Any
 
 import yaml
 from jarvis.agent import Agent
-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
 import sys
 
@@ -31,7 +31,7 @@ class GitCommitTool:
             os.system("git add .")
             PrettyOutput.print("Get diff...", OutputType.SYSTEM)
             diff = os.popen("git diff --cached --exit-code").read()
-            PrettyOutput.print(diff, OutputType.CODE)
+            PrettyOutput.print(diff, OutputType.CODE, lang="diff")
             prompt = f'''Please generate a commit message for the following changes.
             Format:
             <COMMIT_MESSAGE>

jarvis/jarvis_tools/lsp_find_definition.py

@@ -0,0 +1,134 @@
+import os
+from typing import Dict, Any
+from jarvis.jarvis_lsp.registry import LSPRegistry
+
+class LSPFindDefinitionTool:
+    """Tool for finding symbol definitions in code using LSP."""
+    
+    name = "lsp_find_definition"
+    description = "Find the definition of a symbol in code"
+    parameters = {
+        "file_path": "Path to the file containing the symbol",
+        "line": "Line number (0-based) of the symbol",
+        "character": "Character position in the line",
+        "language": f"Programming language of the file ({', '.join(LSPRegistry.get_global_lsp_registry().get_supported_languages())})"
+    }
+    
+    @staticmethod
+    def check() -> bool:
+        """Check if any LSP server is available."""
+        registry = LSPRegistry.get_global_lsp_registry()
+        return len(registry.get_supported_languages()) > 0
+    
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute the tool."""
+        file_path = args.get("file_path", "")
+        line = args.get("line", None)
+        character = args.get("character", None)
+        language = args.get("language", "")
+        
+        # Validate inputs
+        if not all([file_path, line is not None, character is not None, language]):
+            return {
+                "success": False,
+                "stderr": "All parameters (file_path, line, character, language) must be provided",
+                "stdout": ""
+            }
+            
+        try:
+            line = int(line)
+            character = int(character)
+        except ValueError:
+            return {
+                "success": False,
+                "stderr": "Line and character must be integers",
+                "stdout": ""
+            }
+            
+        if not os.path.exists(file_path):
+            return {
+                "success": False,
+                "stderr": f"File not found: {file_path}",
+                "stdout": ""
+            }
+            
+        # Get LSP instance
+        registry = LSPRegistry.get_global_lsp_registry()
+        lsp = registry.create_lsp(language)
+        
+        if not lsp:
+            return {
+                "success": False,
+                "stderr": f"No LSP support for language: {language}",
+                "stdout": ""
+            }
+            
+        try:
+            # Initialize LSP
+            if not lsp.initialize(os.path.dirname(os.path.abspath(file_path))):
+                return {
+                    "success": False,
+                    "stderr": "LSP initialization failed",
+                    "stdout": ""
+                }
+                
+            # Get symbol at position
+            symbol = LSPRegistry.get_text_at_position(file_path, line, character)
+            if not symbol:
+                return {
+                    "success": False,
+                    "stderr": f"No symbol found at position {line}:{character}",
+                    "stdout": ""
+                }
+                
+            # Find definition
+            defn = lsp.find_definition(file_path, (line, character))
+            
+            if not defn:
+                return {
+                    "success": True,
+                    "stdout": f"No definition found for '{symbol}'",
+                    "stderr": ""
+                }
+                
+            # Format output
+            def_line = defn["range"]["start"]["line"]
+            def_char = defn["range"]["start"]["character"]
+            context = LSPRegistry.get_line_at_position(defn["uri"], def_line).strip()
+            
+            output = [
+                f"Definition of '{symbol}':",
+                f"File: {defn['uri']}",
+                f"Line {def_line + 1}, Col {def_char + 1}: {context}"
+            ]
+            
+            # Get a few lines of context around the definition
+            try:
+                with open(defn["uri"], 'r') as f:
+                    lines = f.readlines()
+                    start = max(0, def_line - 2)
+                    end = min(len(lines), def_line + 3)
+                    
+                    if start < def_line:
+                        output.append("\nContext:")
+                        for i in range(start, end):
+                            prefix = ">" if i == def_line else " "
+                            output.append(f"{prefix} {i+1:4d} | {lines[i].rstrip()}")
+            except Exception:
+                pass
+            
+            return {
+                "success": True,
+                "stdout": "\n".join(output),
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "stderr": f"Error finding definition: {str(e)}",
+                "stdout": ""
+            }
+        finally:
+            if lsp:
+                lsp.shutdown()

jarvis/jarvis_tools/lsp_find_references.py

@@ -0,0 +1,111 @@
+import os
+from typing import Dict, Any
+from jarvis.jarvis_lsp.registry import LSPRegistry
+
+class LSPFindReferencesTool:
+    """Tool for finding references to symbols in code using LSP."""
+    
+    name = "lsp_find_references"
+    description = "Find all references to a symbol in code"
+    parameters = {
+        "file_path": "Path to the file containing the symbol",
+        "line": "Line number (0-based) of the symbol",
+        "character": "Character position in the line",
+        "language": f"Programming language of the file ({', '.join(LSPRegistry.get_global_lsp_registry().get_supported_languages())})"
+    }
+    
+    @staticmethod
+    def check() -> bool:
+        """Check if any LSP server is available."""
+        registry = LSPRegistry.get_global_lsp_registry()
+        return len(registry.get_supported_languages()) > 0
+    
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute the tool."""
+        file_path = args.get("file_path", "")
+        line = args.get("line", None)
+        character = args.get("character", None)
+        language = args.get("language", "")
+        
+        # Validate inputs
+        if not all([file_path, line is not None, character is not None, language]):
+            return {
+                "success": False,
+                "stderr": "All parameters (file_path, line, character, language) must be provided",
+                "stdout": ""
+            }
+            
+        try:
+            line = int(line)
+            character = int(character)
+        except ValueError:
+            return {
+                "success": False,
+                "stderr": "Line and character must be integers",
+                "stdout": ""
+            }
+            
+        if not os.path.exists(file_path):
+            return {
+                "success": False,
+                "stderr": f"File not found: {file_path}",
+                "stdout": ""
+            }
+            
+        # Get LSP instance
+        registry = LSPRegistry.get_global_lsp_registry()
+        lsp = registry.create_lsp(language)
+        
+        if not lsp:
+            return {
+                "success": False,
+                "stderr": f"No LSP support for language: {language}",
+                "stdout": ""
+            }
+            
+        try:
+            # Initialize LSP
+            if not lsp.initialize(os.path.dirname(os.path.abspath(file_path))):
+                return {
+                    "success": False,
+                    "stderr": "LSP initialization failed",
+                    "stdout": ""
+                }
+                
+            # Get symbol at position
+            symbol = LSPRegistry.get_text_at_position(file_path, line, character)
+            if not symbol:
+                return {
+                    "success": False,
+                    "stderr": f"No symbol found at position {line}:{character}",
+                    "stdout": ""
+                }
+                
+            # Find references
+            refs = lsp.find_references(file_path, (line, character))
+            
+            # Format output
+            output = [f"References to '{symbol}':\n"]
+            for ref in refs:
+                ref_line = ref["range"]["start"]["line"]
+                ref_char = ref["range"]["start"]["character"]
+                context = LSPRegistry.get_line_at_position(ref["uri"], ref_line).strip()
+                output.append(f"File: {ref['uri']}")
+                output.append(f"Line {ref_line + 1}, Col {ref_char + 1}: {context}")
+                output.append("-" * 40)
+            
+            return {
+                "success": True,
+                "stdout": "\n".join(output) if len(refs) > 0 else f"No references found for '{symbol}'",
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "stderr": f"Error finding references: {str(e)}",
+                "stdout": ""
+            }
+        finally:
+            if lsp:
+                lsp.shutdown()

jarvis/jarvis_tools/lsp_get_diagnostics.py

@@ -0,0 +1,121 @@
+import os
+from typing import Dict, Any
+from jarvis.jarvis_lsp.registry import LSPRegistry
+
+class LSPGetDiagnosticsTool:
+    """Tool for getting diagnostics (errors, warnings) from code using LSP."""
+    
+    name = "lsp_get_diagnostics"
+    description = "Get diagnostic information (errors, warnings) from code files"
+    parameters = {
+        "file_path": "Path to the file to analyze",
+        "language": f"Programming language of the file ({', '.join(LSPRegistry.get_global_lsp_registry().get_supported_languages())})"
+    }
+    
+    @staticmethod
+    def check() -> bool:
+        """Check if any LSP server is available."""
+        registry = LSPRegistry.get_global_lsp_registry()
+        return len(registry.get_supported_languages()) > 0
+    
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute the tool."""
+        file_path = args.get("file_path", "")
+        language = args.get("language", "")
+        
+        # Validate inputs
+        if not all([file_path, language]):
+            return {
+                "success": False,
+                "stderr": "Both file_path and language must be provided",
+                "stdout": ""
+            }
+            
+        if not os.path.exists(file_path):
+            return {
+                "success": False,
+                "stderr": f"File not found: {file_path}",
+                "stdout": ""
+            }
+            
+        # Get LSP instance
+        registry = LSPRegistry.get_global_lsp_registry()
+        lsp = registry.create_lsp(language)
+        
+        if not lsp:
+            return {
+                "success": False,
+                "stderr": f"No LSP support for language: {language}",
+                "stdout": ""
+            }
+            
+        try:
+            # Initialize LSP
+            if not lsp.initialize(os.path.dirname(os.path.abspath(file_path))):
+                return {
+                    "success": False,
+                    "stderr": "LSP initialization failed",
+                    "stdout": ""
+                }
+                
+            # Get diagnostics
+            diagnostics = lsp.get_diagnostics(file_path)
+            
+            if not diagnostics:
+                return {
+                    "success": True,
+                    "stdout": "No issues found in the file",
+                    "stderr": ""
+                }
+                
+            # Format output
+            output = ["Diagnostics:"]
+            severity_map = {1: "Error", 2: "Warning", 3: "Info", 4: "Hint"}
+            
+            # Sort diagnostics by severity and line number
+            sorted_diagnostics = sorted(
+                diagnostics,
+                key=lambda x: (x["severity"], x["range"]["start"]["line"])
+            )
+            
+            for diag in sorted_diagnostics:
+                severity = severity_map.get(diag["severity"], "Unknown")
+                start = diag["range"]["start"]
+                line = LSPRegistry.get_line_at_position(file_path, start["line"]).strip()
+                
+                output.extend([
+                    f"\n{severity} at line {start['line'] + 1}, column {start['character'] + 1}:",
+                    f"Message: {diag['message']}",
+                    f"Code: {line}",
+                    "-" * 60
+                ])
+                
+                # Add related information if available
+                if diag.get("relatedInformation"):
+                    output.append("Related information:")
+                    for info in diag["relatedInformation"]:
+                        info_line = LSPRegistry.get_line_at_position(
+                            info["location"]["uri"],
+                            info["location"]["range"]["start"]["line"]
+                        ).strip()
+                        output.extend([
+                            f"  - {info['message']}",
+                            f"    at {info['location']['uri']}:{info['location']['range']['start']['line'] + 1}",
+                            f"    {info_line}"
+                        ])
+            
+            return {
+                "success": True,
+                "stdout": "\n".join(output),
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "stderr": f"Error getting diagnostics: {str(e)}",
+                "stdout": ""
+            }
+        finally:
+            if lsp:
+                lsp.shutdown()