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

jarvis/tools/code_review.py

@@ -0,0 +1,210 @@
+from typing import Dict, Any, List
+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
+import re
+
+class CodeReviewTool:
+    name = "code_review"
+    description = "Autonomous code review agent for code changes analysis"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "review_type": {
+                "type": "string",
+                "description": "Type of review: 'commit' for specific commit, 'current' for current changes",
+                "enum": ["commit", "current"],
+                "default": "current"
+            },
+            "commit_sha": {
+                "type": "string",
+                "description": "Target commit SHA to analyze (required for review_type='commit')"
+            }
+        },
+        "required": []
+    }
+
+    def __init__(self):
+        init_env()
+        self.repo_root = find_git_root()
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            review_type = args.get("review_type", "current").strip()
+            
+            # Build git diff command based on review type
+            if review_type == "commit":
+                if "commit_sha" not in args:
+                    return {
+                        "success": False,
+                        "stdout": {},
+                        "stderr": "commit_sha is required for commit review type"
+                    }
+                commit_sha = args["commit_sha"].strip()
+                diff_cmd = f"git show {commit_sha} | cat -"
+            else:  # current changes
+                diff_cmd = "git diff HEAD | cat -"
+            
+            # Execute git diff command
+            try:
+                diff_output = subprocess.check_output(diff_cmd, shell=True, text=True)
+                if not diff_output:
+                    return {
+                        "success": False,
+                        "stdout": {},
+                        "stderr": "No changes to review"
+                    }
+                PrettyOutput.print(diff_output, OutputType.CODE, lang="diff")
+            except subprocess.CalledProcessError as e:
+                return {
+                    "success": False,
+                    "stdout": {},
+                    "stderr": f"Failed to get diff: {str(e)}"
+                }
+
+            system_prompt = """You are an autonomous code review expert. Perform in-depth analysis following these guidelines:
+
+IMPORTANT:
+- Only analyze the provided diff content
+- Do NOT make assumptions about code not shown
+- Do NOT invent or imagine potential issues
+- Report ONLY issues that can be directly observed
+- If something is unclear, state it explicitly rather than making assumptions
+
+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 from the diff
+- Suggest actionable improvements based on observed code
+- Highlight security risks clearly with evidence from the code
+- Separate technical debt from blockers
+- If certain aspects cannot be reviewed due to limited context, note this explicitly
+- Do not speculate about code not shown in the diff
+"""
+            tool_registry = ToolRegistry()
+            tool_registry.dont_use_tools(["code_review"])
+            agent = Agent(
+                system_prompt=system_prompt,
+                name="Code Review Agent",
+                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: # Only describe issues directly observable in the diff
+  severity: # Critical/Major/Minor based on concrete evidence
+  suggestion: # Specific, actionable improvements for the observed code
+</REPORT>""",
+                is_sub_agent=True,
+                tool_registry=tool_registry,
+                platform=PlatformRegistry().get_thinking_platform(),
+                auto_complete=True
+            )
+            result = agent.run(diff_output)
+            return {
+                "success": True,
+                "stdout": result,
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": {},
+                "stderr": f"Review failed: {str(e)}"
+            }
+        
+
+def _extract_code_report(result: str) -> str:
+    sm = re.search(r"<REPORT>(.*?)</REPORT>", result, re.DOTALL)
+    if sm:
+        return sm.group(1)
+    return ""
+
+def main():
+    """CLI entry point"""
+    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('--commit', help='Commit SHA to review (required for commit type)')
+    args = parser.parse_args()
+    
+    # Validate arguments
+    if args.type == 'commit' and not args.commit:
+        parser.error("--commit is required when type is 'commit'")
+    
+    tool = CodeReviewTool()
+    tool_args = {
+        "review_type": args.type
+    }
+    if args.commit:
+        tool_args["commit_sha"] = args.commit
+    
+    result = tool.execute(tool_args)
+    
+    if result["success"]:
+        PrettyOutput.section("Autonomous Review Result:", OutputType.SUCCESS)
+        report = _extract_code_report(result["stdout"])
+        PrettyOutput.print(report, OutputType.SUCCESS, lang="yaml")
+        
+    else:
+        PrettyOutput.print(result["stderr"], OutputType.ERROR)
+
+if __name__ == "__main__":
+    main()

jarvis/tools/create_code_test_agent.py

@@ -0,0 +1,115 @@
+from typing import Dict, Any
+from jarvis.agent import Agent
+from jarvis.tools.registry import ToolRegistry
+import subprocess
+
+class TestAgentTool:
+    name = "create_code_test_agent"
+    description = "Create testing agent for specific commit analysis"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "name": {
+                "type": "string",
+                "description": "Identifier for the test agent"
+            },
+            "test_scope": {
+                "type": "string", 
+                "enum": ["unit", "integration", "e2e"],
+                "description": "Testing focus area"
+            },
+            "commit_sha": {
+                "type": "string",
+                "description": "Commit SHA to analyze"
+            }
+        },
+        "required": ["name", "test_scope", "commit_sha"]
+    }
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """Execute commit-focused testing"""
+        try:
+            if not self._is_valid_commit(args["commit_sha"]):
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": f"Invalid commit SHA: {args['commit_sha']}"
+                }
+
+            tool_registry = ToolRegistry()  
+            tool_registry.dont_use_tools(["create_code_test_agent"])
+
+            test_agent = Agent(
+                system_prompt=self._build_system_prompt(args),
+                name=f"TestAgent({args['name']})",
+                is_sub_agent=True,
+                tool_registry=tool_registry
+            )
+
+            result = test_agent.run(
+                f"Analyze and test changes in commit {args['commit_sha'].strip()}"
+            )
+
+            return {
+                "success": True,
+                "stdout": result,
+                "stderr": ""
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"Commit testing failed: {str(e)}"
+            }
+
+    def _is_valid_commit(self, commit_sha: str) -> bool:
+        """Validate commit exists in repository"""
+        try:
+            cmd = f"git cat-file -t {commit_sha}"
+            result = subprocess.run(
+                cmd.split(), 
+                capture_output=True, 
+                text=True,
+                check=True
+            )
+            return "commit" in result.stdout
+        except subprocess.CalledProcessError:
+            return False
+
+    def _build_system_prompt(self, args: Dict) -> str:
+        return """You are a Commit Testing Specialist. Follow this protocol:
+
+【Testing Protocol】
+1. Commit Analysis:
+   - Analyze code changes in target commit
+   - Identify modified components
+   - Assess change impact scope
+
+2. Test Strategy:
+   - Determine required test types
+   - Verify backward compatibility
+   - Check interface contracts
+
+3. Test Execution:
+   - Execute relevant test suites
+   - Compare pre/post-commit behavior
+   - Validate cross-component interactions
+
+4. Reporting:
+   - List affected modules
+   - Risk assessment matrix
+   - Performance impact analysis
+   - Security implications
+
+【Output Requirements】
+- Test coverage analysis
+- Behavioral change summary
+- Critical issues prioritized
+- Actionable recommendations
+
+【Key Principles】
+1. Focus on delta changes
+2. Maintain test isolation
+3. Preserve historical baselines
+4. Automate verification steps
+5. Document test evidence"""

jarvis/tools/create_ctags_agent.py

@@ -0,0 +1,164 @@
+from typing import Dict, Any
+import subprocess
+import os
+from pathlib import Path
+
+import yaml
+from jarvis.agent import Agent
+from jarvis.tools.registry import ToolRegistry
+from jarvis.utils import OutputType, PrettyOutput, get_multiline_input, init_env
+
+ctags_system_prompt = """You are a Ctags Expert Agent specializing in code analysis using Exuberant Ctags. Follow this protocol:
+
+【OUTPUT OPTIMIZATION】
+1. Filter with grep:
+   ctags -x <symbol> | grep -E 'pattern'
+2. Limit output lines:
+   head -n 20
+3. Context preview:
+   grep -A 3 -B 3 <line> <file>
+4. Column selection:
+   cut -f 1,3
+5. Sort and deduplicate:
+   sort | uniq
+
+【WORKFLOW】
+1. REQUIREMENT ANALYSIS
+   - Analyze query for symbols/patterns
+   - Determine search scope
+   - Select ctags options
+   - Plan output filtering
+
+2. TAGS MANAGEMENT
+   - Generate/update tags file:
+     ctags -R --languages=<lang> --exclude=<pattern>
+   - Verify tags file integrity
+   - Maintain tags file versioning
+
+3. SYMBOL PROCESSING
+   - Search symbols using:
+     grep -n <symbol> tags
+     ctags -x --<filter>
+   - Analyze symbol relationships
+   - Map symbol dependencies
+   - Apply output filters:
+     * Remove noise with grep -v
+     * Highlight key fields with awk
+     * Truncate long lines with cut
+
+4. OUTPUT GENERATION
+   - Format results as YAML
+   - Include file paths and line numbers
+   - Add symbol metadata
+   - Limit to 20 key results
+   - Exclude temporary files
+   - Compress repetitive info
+
+【COMMAND REFERENCE】
+1. Generate Tags:
+   ctags -R --fields=+nKSt --extras=+fq -V * 
+
+2. Search Patterns:
+   ctags -x --c-types=f 
+   ctags -x --sort=no <symbol>
+   ctags -x | grep '^main' | head -n 5
+
+3. Language Specific:
+   --languages=Python,Java,C++
+   --python-kinds=-iv
+
+4. Filtering:
+   --exclude=.git
+   --exclude=*.min.js
+   ctags -x | grep -v '_test'  # Exclude tests
+
+【ERROR HANDLING】
+- Missing tags: Regenerate tags
+- Invalid symbols: Use fuzzy search
+- Encoding issues: Use --input-encoding
+- Large codebase: Limit scope
+- Output too long: Add head/grep filters
+
+【NATURAL LANGUAGE PROCESSING】
+1. Query Interpretation:
+   - Identify key terms: "find", "locate", "list", "show"
+   - Detect symbol types: class, function, variable
+   - Recognize relationships: "calls", "inherits", "uses"
+
+2. Query Types:
+   - Location: "Where is X defined?"
+   - References: "Who calls Y?"
+   - Hierarchy: "Show subclasses of Z"
+   - Impact: "What uses this module?"
+
+3. Auto Command Mapping:
+   | Query Pattern                | Ctags Command                      |
+   |------------------------------|------------------------------------|
+   | Find definitions of X         | ctags -x --<lang>-kinds=f | less   |
+   | List all functions in Y       | ctags -x --filter='function'       |
+   | Show callers of Z             | ctags --extra=+q -x | grep Z       |
+   | Find interface implementations| ctags -x --_traits=yes             |
+
+4. Context Handling:
+   - Detect language from file extensions
+   - Auto-detect project root
+   - Apply language-specific filters
+   - Choose appropriate output format:
+      * Simple list for single results
+      * Table for multiple entries
+      * Tree view for hierarchies
+      * JSON when programmatic access needed
+
+【EXAMPLE QUERIES】
+1. "Find all Python functions in src/ that use Redis"
+2. "Show Java classes implementing PaymentService"
+3. "List called methods in auth module"
+4. "Where is User model defined?"
+5. "What config files reference database settings?"
+"""
+
+class CtagsTool:
+    name = "create_ctags_agent"
+    description = "Analyze code structure and symbols using natural language queries"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "query": {
+                "type": "string",
+                "description": "Natural language description of code analysis needs"
+            }
+        },
+        "required": ["query"]
+    }
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """Execute code analysis based on natural language query"""
+        try:
+            tool_registry = ToolRegistry()
+            tool_registry.use_tools(["execute_shell"])
+
+            ctags_agent = Agent(
+                system_prompt=ctags_system_prompt,
+                name="Ctags Analysis Agent",
+                is_sub_agent=True,
+                tool_registry=tool_registry
+            )
+
+            analysis_request = f"""
+            Analysis Request: {args['query']}
+            Context: {args.get('context', {})}
+            """
+
+            result = ctags_agent.run(analysis_request)
+
+            return {
+                "success": True,
+                "stdout": result,
+                "stderr": ""
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"Analysis failed: {str(e)}"
+            }

jarvis/tools/create_sub_agent.py

@@ -2,6 +2,7 @@ from typing import Dict, Any
 
 
 from jarvis.agent import Agent, origin_agent_system_prompt
+from jarvis.tools.registry import ToolRegistry
 from jarvis.utils import OutputType, PrettyOutput
 
 
@@ -58,12 +59,11 @@ class SubAgentTool:
             if goal:
                 task_description += f"\n\nCompletion goal:\n{goal}"
 
-            
 
             # Create sub-agent
             sub_agent = Agent(
                 system_prompt=origin_agent_system_prompt,
-                name=agent_name,
+                name=f"Agent({agent_name})",
                 is_sub_agent=True
             )
 

jarvis/tools/execute_shell.py

@@ -29,7 +29,7 @@ class ShellTool:
     def execute(self, args: Dict) -> Dict[str, Any]:
         """Execute shell command"""
         try:
-            command = args["command"]
+            command = args["command"].strip()
             
             # Generate temporary file name
             output_file = os.path.join(tempfile.gettempdir(), f"jarvis_shell_{os.getpid()}.log")
@@ -61,7 +61,7 @@ class ShellTool:
                 Path(output_file).unlink(missing_ok=True)
             
             return {
-                "success": return_code == 0,
+                "success": True,
                 "stdout": output,
                 "stderr": "",
             }

jarvis/tools/file_operation.py

@@ -37,8 +37,8 @@ class FileOperationTool:
     def execute(self, args: Dict) -> Dict[str, Any]:
         """Execute file operations"""
         try:
-            operation = args["operation"]
-            filepath = args["filepath"]
+            operation = args["operation"].strip()
+            filepath = args["filepath"].strip()
             encoding = args.get("encoding", "utf-8")
             
             # Record the operation and the full path

jarvis/tools/find_in_codebase.py

@@ -0,0 +1,78 @@
+from typing import Dict, Any
+from jarvis.jarvis_code_agent.file_select import select_files
+from jarvis.utils import OutputType, PrettyOutput, dont_use_local_model, find_git_root
+from jarvis.jarvis_codebase.main import CodeBase
+
+class FindInCodebaseTool:
+    """Tool for searching files in codebase based on requirements"""
+    
+    name = "find_in_codebase"
+    description = "Search and identify relevant code files in the codebase based on requirements description, using semantic search"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "query": {
+                "type": "string",
+                "description": "The search query or requirement description"
+            },
+            "top_k": {
+                "type": "integer",
+                "description": "Maximum number of results to return",
+                "default": 20
+            }
+        },
+        "required": ["query"]
+    }
+
+    @staticmethod
+    def check() -> bool:
+        return not dont_use_local_model()
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """Execute the search
+        
+        Args:
+            args: Dictionary containing:
+                - query: Search query string
+                - top_k: Maximum number of results (optional)
+                
+        Returns:
+            Dict containing:
+                - success: Boolean indicating success
+                - stdout: Search results in YAML format
+                - stderr: Error message if any
+        """
+        try:
+            query = args["query"]
+            top_k = args.get("top_k", 20)
+
+            root_dir = find_git_root()
+
+            codebase = CodeBase(root_dir)
+
+            # Search for relevant files
+            results = codebase.search_similar(query, top_k)
+
+            results = select_files(results, root_dir)
+
+            if not results:
+                return {
+                    "success": True,
+                    "stdout": "files: []\n",
+                    "stderr": "No relevant files found"
+                }
+
+
+            return {
+                "success": True,
+                "stdout": "\n".join(results),
+                "stderr": ""
+            }
+
+        except Exception as e:
+            PrettyOutput.print(f"Search error: {str(e)}", OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"Failed to execute search: {str(e)}"
+            }

jarvis/tools/git_commiter.py

@@ -0,0 +1,68 @@
+import os
+import re
+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.utils import OutputType, PrettyOutput, init_env
+import sys
+
+
+class GitCommitTool:
+    name = "git_commit_agent"
+    description = "Automatically generate and execute git commits based on code changes"
+    parameters = {"properties": {}, "required": []}
+
+    def _extract_commit_message(self, message):
+        r = re.search(r"<COMMIT_MESSAGE>(.*)</COMMIT_MESSAGE>", message, re.DOTALL)
+        if r:
+            return ';'.join(r.group(1).strip().splitlines())
+        return "Unknown commit message"
+    
+    def _get_last_commit_hash(self):
+        return os.popen("git log -1 --pretty=%H").read().strip()
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """Execute automatic commit process"""
+        try:
+            PrettyOutput.print("Add files to commit...", OutputType.SYSTEM)
+            os.system("git add .")
+            PrettyOutput.print("Get diff...", OutputType.SYSTEM)
+            diff = os.popen("git diff --cached --exit-code").read()
+            PrettyOutput.print(diff, OutputType.CODE, lang="diff")
+            prompt = f'''Please generate a commit message for the following changes.
+            Format:
+            <COMMIT_MESSAGE>
+            type(scope): description
+            </COMMIT_MESSAGE>
+            
+            Don't include any other information.
+
+            {diff}
+            '''
+            PrettyOutput.print("Generate commit message...", OutputType.SYSTEM)
+            platform = PlatformRegistry().get_codegen_platform()
+            platform.set_suppress_output(True)
+            commit_message = platform.chat_until_success(prompt)
+            commit_message = self._extract_commit_message(commit_message)
+            PrettyOutput.print("Commit...", OutputType.INFO)
+            os.popen(f"git commit -m '{commit_message}'")
+
+            commit_hash = self._get_last_commit_hash()
+
+            PrettyOutput.section(f"Commit hash: {commit_hash}\nCommit message: {commit_message}", OutputType.SUCCESS)
+
+            return {"success": True, "stdout": yaml.safe_dump({"commit_hash": commit_hash, "commit_message": commit_message}), "stderr": ""}
+
+        except Exception as e:
+            return {"success": False, "stdout": "", "stderr": f"Commit error: {str(e)}"}
+
+def main():
+    init_env()
+    tool = GitCommitTool()
+    tool.execute({})
+
+if __name__ == "__main__":
+    sys.exit(main())