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

jarvis/tools/rag.py

@@ -66,14 +66,16 @@ class RAGTool:
             if not os.path.exists(dir_path):
                 return {
                     "success": False,
-                    "error": f"Directory does not exist: {dir_path}"
+                    "stdout": "",
+                    "stderr": f"Directory does not exist: {dir_path}"
                 }
                 
             # Check if it is a directory
             if not os.path.isdir(dir_path):
                 return {
                     "success": False,
-                    "error": f"The path is not a directory: {dir_path}"
+                    "stdout": "",
+                    "stderr": f"The path is not a directory: {dir_path}"
                 }
                 
             # Get RAG instance
@@ -91,7 +93,8 @@ class RAGTool:
             if response is None:
                 return {
                     "success": False,
-                    "error": "Failed to get answer, possibly no relevant documents found"
+                    "stdout": "",
+                    "stderr": "Failed to get answer, possibly no relevant documents found"
                 }
                 
             return {
@@ -104,7 +107,8 @@ class RAGTool:
             PrettyOutput.print(f"Document question and answer failed: {str(e)}", OutputType.ERROR)
             return {
                 "success": False,
-                "error": f"Execution failed: {str(e)}"
+                "stdout": "",
+                "stderr": f"Execution failed: {str(e)}"
             }
 
 def main():
@@ -128,7 +132,7 @@ def main():
         PrettyOutput.print("\nAnswer:", OutputType.INFO)
         PrettyOutput.print(result["stdout"], OutputType.INFO)
     else:
-        PrettyOutput.print(result["error"], OutputType.ERROR)
+        PrettyOutput.print(result["stderr"], OutputType.ERROR)
 
 if __name__ == "__main__":
     main() 

jarvis/tools/read_webpage.py

@@ -67,10 +67,12 @@ class WebpageTool:
         except requests.RequestException as e:
             return {
                 "success": False,
-                "error": f"Webpage request failed: {str(e)}"
+                "stdout": "",
+                "stderr": f"Webpage request failed: {str(e)}"
             }
         except Exception as e:
             return {
                 "success": False,
-                "error": f"Failed to parse webpage: {str(e)}"
+                "stdout": "",
+                "stderr": f"Failed to parse webpage: {str(e)}"
             } 

jarvis/tools/registry.py

@@ -48,6 +48,16 @@ class ToolRegistry:
         # Ensure max_context_length is an integer
         self.max_context_length = int(get_max_context_length() * 0.8)
 
+    def use_tools(self, name: List[str]):
+        """Use specified tools"""
+        missing_tools = [tool_name for tool_name in name if tool_name not in self.tools]
+        if missing_tools:
+            PrettyOutput.print(f"Tools {missing_tools} do not exist, available tools: {', '.join(self.tools.keys())}", OutputType.WARNING)
+        self.tools = {tool_name: self.tools[tool_name] for tool_name in name}
+
+    def dont_use_tools(self, names: List[str]):
+        """Remove specified tools from the registry"""
+        self.tools = {name: tool for name, tool in self.tools.items() if name not in names}
     @staticmethod
     def get_global_tool_registry():
         """Get the global tool registry"""
@@ -68,8 +78,8 @@ class ToolRegistry:
             self.register_tool_by_file(str(file_path))
 
     def _load_external_tools(self):
-        """Load external tools from ~/.jarvis_tools"""
-        external_tools_dir = Path.home() / '.jarvis_tools'
+        """Load external tools from ~/.jarvis/tools"""
+        external_tools_dir = Path.home() / '.jarvis/tools'
         if not external_tools_dir.exists():
             return
             
@@ -156,7 +166,7 @@ class ToolRegistry:
         """Execute a specified tool"""
         tool = self.get_tool(name)
         if tool is None:
-            return {"success": False, "error": f"Tool {name} does not exist, available tools: {', '.join(self.tools.keys())}"}
+            return {"success": False, "stderr": f"Tool {name} does not exist, available tools: {', '.join(self.tools.keys())}", "stdout": ""}
         return tool.execute(arguments)
 
     def handle_tool_calls(self, tool_calls: List[Dict]) -> str:
@@ -198,18 +208,20 @@ arguments:
             
             # Execute tool call
             result = self.execute_tool(name, args)
+
+            stdout = result["stdout"]
+            stderr = result.get("stderr", "")
+            output_parts = []
+            if stdout:
+                output_parts.append(f"Output:\n{stdout}")
+            if stderr:
+                output_parts.append(f"Error:\n{stderr}")
+            output = "\n\n".join(output_parts)
+            output = "no output and error" if not output else output
             
             # Process the result
             if result["success"]:
-                stdout = result["stdout"]
-                stderr = result.get("stderr", "")
-                output_parts = []
-                if stdout:
-                    output_parts.append(f"Output:\n{stdout}")
-                if stderr:
-                    output_parts.append(f"Error:\n{stderr}")
-                output = "\n\n".join(output_parts)
-                output = "Tool execution successful, no output and error" if not output else output
+                
                 PrettyOutput.section("Execution successful", OutputType.SUCCESS)
                 
                 # If the output exceeds 4k characters, use a large model to summarize
@@ -251,9 +263,7 @@ Please provide a summary:"""
                         output = f"Output is too long ({len(output)} characters), it is recommended to view the original output.\nPreview of the first 300 characters:\n{output[:300]}..."
             
             else:
-                error_msg = result["error"]
-                output = f"Execution failed: {error_msg}"
-                PrettyOutput.section("Execution failed", OutputType.ERROR)
+                PrettyOutput.section("Execution failed", OutputType.WARNING)
                 
             return output
             

jarvis/tools/search.py

@@ -8,32 +8,32 @@ from urllib.parse import quote
 def bing_search(query):
     try:
         with sync_playwright() as p:
-            # 启动浏览器时设置参数
+            # Set parameters when starting the browser
             browser = p.chromium.launch(
-                headless=True,  # 无头模式
+                headless=True,  # Headless mode
                 args=['--disable-gpu', '--no-sandbox', '--disable-dev-shm-usage']
             )
             
-            # 创建新页面并设置超时
+            # Create a new page and set timeout
             page = browser.new_page(
                 user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36',
                 viewport={'width': 1920, 'height': 1080}
             )
             
-            # 设置页面超时
+            # Set page timeout
             page.set_default_timeout(60000)
             
-            # 访问搜索页面
+            # Visit search page
             url = f"https://www.bing.com/search?q={quote(query)}&form=QBLH&sp=-1"
             page.goto(url, wait_until="networkidle")
             
-            # 等待搜索结果加载
+            # Wait for search results to load
             page.wait_for_selector("#b_results", state="visible", timeout=30000)
             
-            # 等待一下以确保结果完全加载
+            # Wait for a moment to ensure the results are fully loaded
             page.wait_for_timeout(1000)
             
-            # 提取搜索结果
+            # Extract search results
             summaries = page.evaluate("""() => {
                 const results = [];
                 const elements = document.querySelectorAll("#b_results > .b_algo");
@@ -96,7 +96,7 @@ class SearchTool:
             if not results:
                 return []
             
-            # 格式化搜索结果
+            # Format search results
             formatted_results = []
             for result in results[:max_results]:
                 formatted_results.append({
@@ -142,15 +142,16 @@ When answering, pay attention to:
             PrettyOutput.print(f"Search query: {query}", OutputType.INFO)
             PrettyOutput.print(f"Related question: {question}", OutputType.INFO)
             
-            # 获取搜索结果
+            # Get search results
             results = self._search(query, max_results)
             if not results:
                 return {
                     "success": False,
-                    "error": "No search results found"
+                    "stdout": "",
+                    "stderr": "No search results found"
                 }
             
-            # 收集网页内容
+            # Collect webpage content
             contents = []
             for i, result in enumerate(results, 1):
                 try:
@@ -166,7 +167,8 @@ When answering, pay attention to:
             if not contents:
                 return {
                     "success": False,
-                    "error": "No valid search results found"
+                    "stdout": "",
+                    "stderr": "No valid search results found"
                 }
             
             # Extract information
@@ -182,11 +184,12 @@ When answering, pay attention to:
         except Exception as e:
             return {
                 "success": False,
-                "error": f"搜索失败: {str(e)}"
+                "stdout": "",
+                "stderr": f"Search failed: {str(e)}"
             }
 
 def main():
-    """命令行直接运行搜索工具"""
+    """Command line directly run search tool"""
     import argparse
     import sys
     

jarvis/tools/select_code_files.py

@@ -49,16 +49,13 @@ class CodeFileSelecterTool:
             return {
                 "success": True,
                 "stdout": output,
-                "stderr": "",
-                "selected_files": selected_files  # Return the selected files for other tools to use
+                "stderr": ""
             }
 
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
                 "success": False,
-                "error": f"Failed to select files: {str(e)}",
                 "stdout": "",
-                "stderr": str(e),
-                "selected_files": []  # Return empty list on error
+                "stderr": str(e)
             }

jarvis/tools/thinker.py

@@ -1,5 +1,5 @@
 from typing import Dict, Any
-from jarvis.utils import OutputType, PrettyOutput, load_env_from_file
+from jarvis.utils import OutputType, PrettyOutput, init_env
 from jarvis.models.registry import PlatformRegistry
 
 class ThinkerTool:
@@ -104,7 +104,8 @@ Related context:
             if not response:
                 return {
                     "success": False,
-                    "error": "Failed to obtain valid analysis results"
+                    "stdout": "",
+                    "stderr": "Failed to obtain valid analysis results"
                 }
                 
             return {
@@ -117,14 +118,15 @@ Related context:
             PrettyOutput.print(f"Thinking analysis failed: {str(e)}", OutputType.ERROR)
             return {
                 "success": False,
-                "error": f"Execution failed: {str(e)}"
+                "stdout": "",
+                "stderr": f"Execution failed: {str(e)}"
             }
 
 def main():
     """Run tool directly from command line"""
     import argparse
 
-    load_env_from_file()
+    init_env()
     
     parser = argparse.ArgumentParser(description='Deep thinking analysis tool')
     parser.add_argument('--question', required=True, help='The problem to analyze')
@@ -143,7 +145,7 @@ def main():
         PrettyOutput.print("\nAnalysis results:", OutputType.INFO)
         PrettyOutput.print(result["stdout"], OutputType.INFO)
     else:
-        PrettyOutput.print(result["error"], OutputType.ERROR)
+        PrettyOutput.print(result["stderr"], OutputType.ERROR)
 
 if __name__ == "__main__":
     main() 

jarvis/utils.py

@@ -194,10 +194,15 @@ def get_multiline_input(tip: str) -> str:
     
     return "\n".join(lines)
 
-def load_env_from_file():
-    """Load environment variables from ~/.jarvis_env"""
-    env_file = Path.home() / ".jarvis_env"
+def init_env():
+    """Load environment variables from ~/.jarvis/env"""
+    jarvis_dir = Path.home() / ".jarvis"
+    env_file = jarvis_dir / "env"
     
+    # Check if ~/.jarvis directory exists
+    if not jarvis_dir.exists():
+        jarvis_dir.mkdir(parents=True)
+
     if env_file.exists():
         try:
             with open(env_file, "r", encoding="utf-8") as f:
@@ -210,7 +215,7 @@ def load_env_from_file():
                         except ValueError:
                             continue
         except Exception as e:
-            PrettyOutput.print(f"Warning: Failed to read ~/.jarvis_env: {e}", OutputType.WARNING)
+            PrettyOutput.print(f"Warning: Failed to read {env_file}: {e}", OutputType.WARNING)
     
     
 def while_success(func, sleep_time: float = 0.1):
@@ -242,19 +247,24 @@ def find_git_root(dir="."):
 def load_embedding_model():
     model_name = "BAAI/bge-m3"
     cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
-    model_dir = os.path.join(cache_dir, "models--" + model_name.replace("/", "--"))
-    
-    # Check if model exists
-    if not os.path.exists(model_dir):
-        PrettyOutput.print("Model not found locally, downloading using huggingface-cli...", OutputType.INFO)
-        os.system(f'huggingface-cli download --repo-type model --local-dir {cache_dir} {model_name}' + f' --token {os.getenv("HF_TOKEN")}' if os.getenv("HF_TOKEN") else "")
     
-    # Load model
-    embedding_model = SentenceTransformer(
-        model_name,
-        cache_folder=cache_dir,
-        local_files_only=True
-    )
+
+    try:
+        # Load model
+        embedding_model = SentenceTransformer(
+            model_name,
+            cache_folder=cache_dir,
+            local_files_only=True
+        )
+    except Exception as e:
+        PrettyOutput.print(f"Failed to load embedding model: {str(e)}", OutputType.ERROR)
+        os.system(f'huggingface-cli download --repo-type model --local-dir {cache_dir} {model_name}')
+        # Load model
+        embedding_model = SentenceTransformer(
+            model_name,
+            cache_folder=cache_dir,
+            local_files_only=True
+        )
     
     return embedding_model
 
@@ -262,26 +272,35 @@ def load_rerank_model():
     """Load reranking model"""
     model_name = "BAAI/bge-reranker-v2-m3"
     cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
-    model_dir = os.path.join(cache_dir, "models--" + model_name.replace("/", "--"))
     
     PrettyOutput.print(f"Loading reranking model: {model_name}...", OutputType.INFO)
     
-    # Check if model exists
-    if not os.path.exists(model_dir):
-        PrettyOutput.print("Model not found locally, downloading using huggingface-cli...", OutputType.INFO)
-        os.system(f'huggingface-cli download --repo-type model --local-dir {cache_dir} {model_name}' + f' --token {os.getenv("HF_TOKEN")}' if os.getenv("HF_TOKEN") else "")
-    
-    # Load model and tokenizer
-    tokenizer = AutoTokenizer.from_pretrained(
-        model_name,
-        cache_dir=cache_dir,
-        local_files_only=True
-    )
-    model = AutoModelForSequenceClassification.from_pretrained(
-        model_name,
-        cache_dir=cache_dir,
-        local_files_only=True
-    )
+    try:
+        # Load model and tokenizer
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_name,
+            cache_dir=cache_dir,
+            local_files_only=True
+        )
+        model = AutoModelForSequenceClassification.from_pretrained(
+            model_name,
+            cache_dir=cache_dir,
+            local_files_only=True
+        )
+    except Exception as e:
+        PrettyOutput.print(f"Failed to load reranking model: {str(e)}", OutputType.ERROR)
+        os.system(f'huggingface-cli download --repo-type model --local-dir {cache_dir} {model_name}')
+        # Load model and tokenizer
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_name,
+            cache_dir=cache_dir,
+            local_files_only=True
+        )
+        model = AutoModelForSequenceClassification.from_pretrained(
+            model_name,
+            cache_dir=cache_dir,
+            local_files_only=True
+        )
     
     # Use GPU if available
     if torch.cuda.is_available():
@@ -341,7 +360,7 @@ def _create_methodology_embedding(embedding_model: Any, methodology_text: str) -
 def load_methodology(user_input: str) -> str:
     """Load methodology and build vector index"""
     PrettyOutput.print("Loading methodology...", OutputType.PROGRESS)
-    user_jarvis_methodology = os.path.expanduser("~/.jarvis_methodology")
+    user_jarvis_methodology = os.path.expanduser("~/.jarvis/methodology")
     if not os.path.exists(user_jarvis_methodology):
         return ""
 

{jarvis_ai_assistant-0.1.99.dist-info → jarvis_ai_assistant-0.1.101.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jarvis-ai-assistant
-Version: 0.1.99
+Version: 0.1.101
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire
@@ -125,7 +125,7 @@ pip install jarvis-ai-assistant
 
 ## 🔧 Configuration
 
-Jarvis supports configuration through environment variables that can be set in the `~/.jarvis_env` file:
+Jarvis supports configuration through environment variables that can be set in the `~/.jarvis/env` file:
 
 | Environment Variable | Description | Default Value | Required |
 |---------|------|--------|------|
@@ -204,7 +204,7 @@ jarvis-search "your query" --max 3
 
 ### Tool Locations
 - Built-in tools: `src/jarvis/tools/`
-- User tools: `~/.jarvis_tools/`
+- User tools: `~/.jarvis/tools/`
 
 
 ### Key Features
@@ -241,7 +241,7 @@ jarvis-search "your query" --max 3
 
 ### Adding New Tools
 
-Create a new Python file in `~/.jarvis_tools/` or `src/jarvis/tools/`:
+Create a new Python file in `~/.jarvis/tools/` or `src/jarvis/tools/`:
 
 ```python
 from typing import Dict, Any
@@ -273,7 +273,6 @@ class CustomTool:
                 "success": bool,
                 "stdout": str,  # On success
                 "stderr": str,  # Optional error details
-                "error": str    # On failure
             }
         """
         try:
@@ -281,18 +280,20 @@ class CustomTool:
             result = "Tool execution result"
             return {
                 "success": True,
-                "stdout": result
+                "stdout": result,
+                "stderr": ""
             }
         except Exception as e:
             return {
                 "success": False,
-                "error": str(e)
+                "stdout": "",
+                "stderr": str(e)
             }
 ```
 
 ### Adding New Models
 
-Create a new Python file in `~/.jarvis_models/`:
+Create a new Python file in `~/.jarvis/models/`:
 
 ```python
 from typing import Dict, List

jarvis_ai_assistant-0.1.101.dist-info/RECORD

@@ -0,0 +1,51 @@
+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,,

jarvis/tools/codebase_qa.py

@@ -1,72 +0,0 @@
-import os
-from typing import Any, Dict
-from jarvis.jarvis_codebase.main import CodeBase
-from jarvis.utils import find_git_root, PrettyOutput, OutputType
-
-class CodebaseQATool:
-    """Codebase QA Tool"""
-    
-    name = "codebase_qa"
-    description = "Answer questions about the codebase, can query and understand code functionality, structure, and implementation details"
-    parameters = {
-        "type": "object",
-        "properties": {
-            "dir": {
-                "type": "string",
-                "description": "Project root directory"
-            },
-            "question": {
-                "type": "string",
-                "description": "Question about the codebase"
-            },
-            "top_k": {
-                "type": "integer",
-                "description": "Number of relevant files to search",
-                "default": 5
-            }
-        },
-        "required": ["question"]
-    }
-    
-    def execute(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Execute codebase QA"""
-        try:
-            dir = params.get("dir")
-            question = params["question"]
-            top_k = params.get("top_k", 5)
-            
-            # 初始化代码库
-            current_dir = os.getcwd()
-            root_dir = find_git_root(dir or current_dir)
-            if not root_dir:
-                return {
-                    "success": False,
-                    "stdout": "",
-                    "stderr": "Error: Current directory is not in a Git repository",
-                    "error": "NotInGitRepository"
-                }
-
-            os.chdir(root_dir)
-            codebase = CodeBase(root_dir)
-            # 生成索引
-
-            codebase.generate_codebase()
-            # 执行问答
-            response = codebase.ask_codebase(question, top_k)
-            os.chdir(current_dir)
-            return {
-                "success": True,
-                "stdout": response,
-                "stderr": "",
-                "error": None
-            }
-            
-        except Exception as e:
-            PrettyOutput.print(f"Codebase QA error: {str(e)}", output_type=OutputType.ERROR)
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"Error executing codebase QA: {str(e)}",
-                "error": str(type(e).__name__)
-            }
-