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

jarvis/jarvis_tools/lsp_get_document_symbols.py

@@ -0,0 +1,87 @@
+import os
+from typing import Dict, Any
+from jarvis.jarvis_lsp.registry import LSPRegistry
+
+class LSPGetDocumentSymbolsTool:
+    """Tool for getting document symbols in code files using LSP."""
+    
+    name = "lsp_get_document_symbols"
+    description = "Get document symbols (functions, classes, variables) in 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", "")
+        
+        if not file_path or not 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 symbols
+            symbols = lsp.get_document_symbols(file_path)
+            
+            # Format output
+            output = []
+            for symbol in symbols:
+                start = symbol["range"]["start"]
+                name = LSPRegistry.get_text_at_position(file_path, start["line"], start["character"])
+                line = LSPRegistry.get_line_at_position(file_path, start["line"]).strip()
+                output.append(f"Symbol: {name}")
+                output.append(f"Line {start['line'] + 1}: {line}")
+                output.append("-" * 40)
+            
+            return {
+                "success": True,
+                "stdout": "\n".join(output) if output else "No symbols found",
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "stderr": f"Error finding symbols: {str(e)}",
+                "stdout": ""
+            }
+        finally:
+            if lsp:
+                lsp.shutdown()

jarvis/jarvis_tools/lsp_prepare_rename.py

@@ -0,0 +1,130 @@
+import os
+from typing import Dict, Any
+from jarvis.jarvis_lsp.registry import LSPRegistry
+
+class LSPPrepareRenameTool:
+    """Tool for checking if a symbol can be renamed using LSP."""
+    
+    name = "lsp_prepare_rename"
+    description = "Check if a symbol can be safely renamed and show all locations that would be affected"
+    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": ""
+                }
+                
+            # Check if rename is possible
+            rename_info = lsp.prepare_rename(file_path, (line, character))
+            if not rename_info:
+                return {
+                    "success": True,
+                    "stdout": f"Symbol '{symbol}' cannot be renamed. It might be:\n" +
+                             "- A built-in or library symbol\n" +
+                             "- A read-only symbol\n" +
+                             "- Not a valid identifier",
+                    "stderr": ""
+                }
+                
+            # Get all references to show affected locations
+            refs = lsp.find_references(file_path, (line, character))
+            
+            # Format output
+            output = [
+                f"Symbol '{symbol}' can be renamed.",
+                f"\nRenaming will affect the following locations:"
+            ]
+            
+            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.extend([
+                    f"\nFile: {ref['uri']}",
+                    f"Line {ref_line + 1}, Col {ref_char + 1}: {context}"
+                ])
+            
+            output.append("\nNote: Make sure to review all locations before performing the rename.")
+            
+            return {
+                "success": True,
+                "stdout": "\n".join(output),
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "stderr": f"Error checking rename possibility: {str(e)}",
+                "stdout": ""
+            }
+        finally:
+            if lsp:
+                lsp.shutdown()

jarvis/jarvis_tools/lsp_validate_edit.py

@@ -0,0 +1,141 @@
+import os
+from typing import Dict, Any
+from jarvis.jarvis_lsp.registry import LSPRegistry
+
+class LSPValidateEditTool:
+    """Tool for validating code edits using LSP."""
+    
+    name = "lsp_validate_edit"
+    description = "Validate if a proposed code edit is syntactically correct"
+    parameters = {
+        "file_path": "Path to the file to edit",
+        "start_line": "Starting line number (0-based) of the edit",
+        "start_character": "Starting character position in the start line",
+        "end_line": "Ending line number (0-based) of the edit",
+        "end_character": "Ending character position in the end line",
+        "new_text": "New text to insert",
+        "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", "")
+        start_line = args.get("start_line", None)
+        start_character = args.get("start_character", None)
+        end_line = args.get("end_line", None)
+        end_character = args.get("end_character", None)
+        new_text = args.get("new_text", "")
+        language = args.get("language", "")
+        
+        # Validate inputs
+        if not all([file_path, start_line is not None, start_character is not None,
+                   end_line is not None, end_character is not None, language]):
+            return {
+                "success": False,
+                "stderr": "All parameters except new_text must be provided",
+                "stdout": ""
+            }
+            
+        try:
+            start_line = int(start_line)
+            start_character = int(start_character)
+            end_line = int(end_line)
+            end_character = int(end_character)
+        except ValueError:
+            return {
+                "success": False,
+                "stderr": "Line and character positions 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": ""
+                }
+                
+            # Prepare edit operation
+            edit = {
+                "range": {
+                    "start": {"line": start_line, "character": start_character},
+                    "end": {"line": end_line, "character": end_character}
+                },
+                "newText": new_text
+            }
+            
+            # Show the edit preview
+            output = ["Edit Preview:"]
+            
+            # Show original code
+            try:
+                with open(file_path, 'r') as f:
+                    lines = f.readlines()
+                    context_start = max(0, start_line - 2)
+                    context_end = min(len(lines), end_line + 3)
+                    
+                    output.append("\nOriginal code:")
+                    for i in range(context_start, context_end):
+                        prefix = ">" if start_line <= i <= end_line else " "
+                        output.append(f"{prefix} {i+1:4d} | {lines[i].rstrip()}")
+            except Exception:
+                pass
+            
+            # Show new text
+            output.extend([
+                "\nNew text to insert:",
+                new_text,
+                "\nEdit range:",
+                f"From line {start_line + 1}, character {start_character}",
+                f"To line {end_line + 1}, character {end_character}"
+            ])
+            
+            # Validate edit
+            is_valid = lsp.validate_edit(file_path, edit)
+            
+            if is_valid:
+                output.append("\nValidation Result: The edit is syntactically correct ✓")
+            else:
+                output.append("\nValidation Result: The edit would introduce syntax errors ✗")
+            
+            return {
+                "success": True,
+                "stdout": "\n".join(output),
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "stderr": f"Error validating edit: {str(e)}",
+                "stdout": ""
+            }
+        finally:
+            if lsp:
+                lsp.shutdown()

jarvis/{tools → jarvis_tools}/methodology.py

@@ -1,7 +1,7 @@
 import os
 import yaml
 from typing import Dict, Optional, Any
-from jarvis.utils import OutputType, PrettyOutput
+from jarvis.utils import OutputType, PrettyOutput, is_use_methodology
 
 
 class MethodologyTool:
@@ -29,6 +29,11 @@ class MethodologyTool:
         },
         "required": ["operation", "problem_type"]
     }
+
+    @staticmethod
+    def check()->bool:
+        """Check if the methodology is enabled"""
+        return is_use_methodology()
     
     def __init__(self):
         """Initialize the experience management tool"""

jarvis/{tools → jarvis_tools}/rag.py

@@ -133,7 +133,7 @@ def main():
     })
     
     if result["success"]:
-        PrettyOutput.print(f"Answer: {result['stdout']}", OutputType.INFO)
+        PrettyOutput.print(f"{result['stdout']}", OutputType.INFO, lang="markdown")
     else:
         PrettyOutput.print(result["stderr"], OutputType.ERROR)
 

jarvis/{tools → jarvis_tools}/read_code.py

@@ -114,34 +114,3 @@ class ReadCodeTool:
                 "stdout": "",
                 "stderr": f"Failed to read code: {str(e)}"
             }
-
-
-def main():
-    """Command line interface for the tool"""
-    import argparse
-    
-    parser = argparse.ArgumentParser(description='Read code file with line numbers')
-    parser.add_argument('filepath', help='Path to the code file')
-    parser.add_argument('--start', type=int, default=0, help='Start line number (0-based)')
-    parser.add_argument('--end', type=int, default=-1, help='End line number (0-based)')
-    
-    args = parser.parse_args()
-    
-    tool = ReadCodeTool()
-    result = tool.execute({
-        "filepath": args.filepath,
-        "start_line": args.start,
-        "end_line": args.end
-    })
-    
-    if result["success"]:
-        print(result["stdout"])
-    else:
-        PrettyOutput.print(result["stderr"], OutputType.ERROR)
-        return 1
-        
-    return 0
-
-
-if __name__ == "__main__":
-    main()

jarvis/{tools → jarvis_tools}/registry.py

@@ -3,12 +3,12 @@ from pathlib import Path
 import sys
 from typing import Any, Callable, Dict, List, Optional
 
-from jarvis.models.registry import PlatformRegistry
-from jarvis.tools.base import Tool
+from jarvis.jarvis_platform.registry import PlatformRegistry
+from jarvis.jarvis_tools.base import Tool
 from jarvis.utils import OutputType, PrettyOutput, get_max_context_length
 
 
-tool_call_help = """Tool Usage Format:
+tool_call_help = """## Tool Usage Format
 
 <TOOL_CALL>
 name: tool_name
@@ -49,7 +49,7 @@ class ToolRegistry:
         """Load tools"""
         tools = self.get_all_tools()
         if tools:
-            tools_prompt = "Available tools:\n"
+            tools_prompt = "## Available tools:\n"
             for tool in tools:
                 tools_prompt += f"- Name: {tool['name']}\n"
                 tools_prompt += f"  Description: {tool['description']}\n"
@@ -136,7 +136,8 @@ class ToolRegistry:
                     if (isinstance(item, type) and 
                         hasattr(item, 'name') and 
                         hasattr(item, 'description') and 
-                        hasattr(item, 'parameters')):
+                        hasattr(item, 'parameters') and
+                        hasattr(item, 'execute')):
 
                         if hasattr(item, "check"):
                             if not item.check():

jarvis/{tools → jarvis_tools}/search.py

@@ -1,7 +1,7 @@
 from typing import Dict, Any, List
-from jarvis.models.registry import PlatformRegistry
+from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.utils import PrettyOutput, OutputType
-from jarvis.tools.read_webpage import WebpageTool
+from jarvis.jarvis_tools.read_webpage import WebpageTool
 from playwright.sync_api import sync_playwright
 from urllib.parse import quote
 

jarvis/utils.py

@@ -4,7 +4,7 @@ import time
 import os
 from enum import Enum
 from datetime import datetime
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 import colorama
 from colorama import Fore, Style as ColoramaStyle
 import numpy as np
@@ -85,7 +85,7 @@ class PrettyOutput:
     """Pretty output using rich"""
     
     # Icons for different output types
-    ICONS = {
+    _ICONS = {
         OutputType.SYSTEM: "🤖",    # Robot - AI assistant
         OutputType.CODE: "📝",      # Notebook - Code
         OutputType.RESULT: "✨",    # Flash - Result
@@ -147,7 +147,7 @@ class PrettyOutput:
             return default_lang
 
     @staticmethod
-    def format(text: str, output_type: OutputType, timestamp: bool = True) -> Text:
+    def _format(text: str, output_type: OutputType, timestamp: bool = True) -> Text:
         """Format output text using rich Text"""
         # Create rich Text object
         formatted = Text()
@@ -157,17 +157,17 @@ class PrettyOutput:
             formatted.append(f"[{datetime.now().strftime('%H:%M:%S')}] ", style="white")
         formatted.append(f"[{get_agent_list()}]", style="blue")
         # Add icon
-        icon = PrettyOutput.ICONS.get(output_type, "")
+        icon = PrettyOutput._ICONS.get(output_type, "")
         formatted.append(f"{icon} ", style=output_type.value)
         
         return formatted
 
     @staticmethod
-    def print(text: str, output_type: OutputType, timestamp: bool = True):
+    def print(text: str, output_type: OutputType, timestamp: bool = True, lang: Optional[str] = None):
         """Print formatted output using rich console"""
         # Get formatted header
-        lang = PrettyOutput._detect_language(text, default_lang='markdown')
-        header = PrettyOutput.format("", output_type, timestamp)
+        lang = lang if lang is not None else PrettyOutput._detect_language(text, default_lang='markdown')
+        header = PrettyOutput._format("", output_type, timestamp)
 
         content = Syntax(text, lang, theme="monokai")
             
@@ -208,14 +208,6 @@ def get_single_line_input(tip: str) -> str:
     })
     return session.prompt(f"{tip}", style=style)
 
-def make_choice_input(tip: str, choices: list) -> str:
-    """Get choice input, support direction key, history function, etc."""
-    session = PromptSession(history=None)
-    style = PromptStyle.from_dict({
-        'prompt': 'ansicyan',
-    })
-    return session.prompt(f"{tip}", style=style)
-
 class FileCompleter(Completer):
     """Custom completer for file paths with fuzzy matching."""
     def __init__(self):
@@ -341,7 +333,7 @@ def init_env():
             with open(env_file, "r", encoding="utf-8") as f:
                 for line in f:
                     line = line.strip()
-                    if line and not line.startswith("#"):
+                    if line and not line.startswith(("#", ";")):
                         try:
                             key, value = line.split("=", 1)
                             os.environ[key.strip()] = value.strip().strip("'").strip('"')
@@ -445,8 +437,7 @@ def load_rerank_model():
     
     return model, tokenizer
 
-def get_max_context_length():
-    return int(os.getenv('JARVIS_MAX_CONTEXT_LENGTH', '131072'))  # 默认128k
+
 
 def is_long_context(files: list) -> bool:
     """Check if the file list belongs to a long context (total characters exceed 80% of the maximum context length)"""
@@ -468,15 +459,12 @@ def is_long_context(files: list) -> bool:
             
     return total_chars > threshold
 
-def get_thread_count():
-    return int(os.getenv('JARVIS_THREAD_COUNT', '1'))  
+
 
 def get_file_md5(filepath: str)->str:    
     return hashlib.md5(open(filepath, "rb").read(100*1024*1024)).hexdigest()
 
 
-def dont_use_local_model():
-    return os.getenv('JARVIS_DONT_USE_LOCAL_MODEL', 'false') == 'true'
 
 
 def _create_methodology_embedding(embedding_model: Any, methodology_text: str) -> np.ndarray:
@@ -576,12 +564,7 @@ def load_methodology(user_input: str) -> str:
         import traceback
         PrettyOutput.print(f"Error trace: {traceback.format_exc()}", OutputType.INFO)
         return ""
-    
-def is_auto_complete() -> bool:
-    return os.getenv('JARVIS_AUTO_COMPLETE', 'false') == 'true'
 
-def is_disable_codebase() -> bool:
-    return os.getenv('JARVIS_DISABLE_CODEBASE', 'false') == 'true'
 
 def user_confirm(tip: str, default: bool = True) -> bool:
     """Prompt the user for confirmation.
@@ -601,4 +584,64 @@ def get_file_line_count(filename: str) -> int:
     try:
         return len(open(filename, "r", encoding="utf-8").readlines())
     except Exception as e:
-        return 0
+        return 0
+    
+def get_max_context_length():
+    return int(os.getenv('JARVIS_MAX_CONTEXT_LENGTH', '131072'))  # 默认128k
+    
+def get_thread_count():
+    return int(os.getenv('JARVIS_THREAD_COUNT', '1'))  
+
+def dont_use_local_model():
+    return os.getenv('JARVIS_DONT_USE_LOCAL_MODEL', 'false') == 'true'
+    
+def is_auto_complete() -> bool:
+    return os.getenv('JARVIS_AUTO_COMPLETE', 'false') == 'true'
+
+def is_disable_codebase() -> bool:
+    return os.getenv('JARVIS_DISABLE_CODEBASE', 'false') == 'true'
+    
+def is_use_methodology() -> bool:
+    return os.getenv('JARVIS_USE_METHODOLOGY', 'true') == 'true'
+
+def is_record_methodology() -> bool:
+    return os.getenv('JARVIS_RECORD_METHODOLOGY', 'true') == 'true'
+
+def is_need_summary() -> bool:
+    return os.getenv('JARVIS_NEED_SUMMARY', 'true') == 'true'
+
+def get_min_paragraph_length() -> int:
+    return int(os.getenv('JARVIS_MIN_PARAGRAPH_LENGTH', '50'))
+
+def get_max_paragraph_length() -> int:
+    return int(os.getenv('JARVIS_MAX_PARAGRAPH_LENGTH', '1000'))
+
+def get_context_window() -> int:
+    return int(os.getenv('JARVIS_CONTEXT_WINDOW', '5'))
+
+def get_shell_name() -> str:
+    return os.getenv('SHELL', 'bash')
+
+def get_normal_platform_name() -> str:
+    return os.getenv('JARVIS_PLATFORM', 'kimi')
+
+def get_normal_model_name() -> str:
+    return os.getenv('JARVIS_MODEL', 'kimi')
+
+def get_codegen_platform_name() -> str:
+    return os.getenv('JARVIS_CODEGEN_PLATFORM', os.getenv('JARVIS_PLATFORM', 'kimi'))
+
+def get_codegen_model_name() -> str:
+    return os.getenv('JARVIS_CODEGEN_MODEL', os.getenv('JARVIS_MODEL', 'kimi'))
+
+def get_thinking_platform_name() -> str:
+    return os.getenv('JARVIS_THINKING_PLATFORM', os.getenv('JARVIS_PLATFORM', 'kimi'))
+
+def get_thinking_model_name() -> str:
+    return os.getenv('JARVIS_THINKING_MODEL', os.getenv('JARVIS_MODEL', 'kimi'))
+
+def get_cheap_platform_name() -> str:
+    return os.getenv('JARVIS_CHEAP_PLATFORM', os.getenv('JARVIS_PLATFORM', 'kimi'))
+
+def get_cheap_model_name() -> str:
+    return os.getenv('JARVIS_CHEAP_MODEL', os.getenv('JARVIS_MODEL', 'kimi'))