jarvis-ai-assistant 0.1.98__py3-none-any.whl → 0.1.100__py3-none-any.whl

jarvis/utils.py

@@ -6,20 +6,35 @@ import time
 import os
 from enum import Enum
 from datetime import datetime
+from typing import Any, Dict
 import colorama
 from colorama import Fore, Style as ColoramaStyle
+import numpy as np
 from prompt_toolkit import PromptSession
 from prompt_toolkit.styles import Style as PromptStyle
 from prompt_toolkit.formatted_text import FormattedText
 from sentence_transformers import SentenceTransformer
 from transformers import AutoModelForSequenceClassification, AutoTokenizer
 import torch
+import yaml
+import faiss
 
 # 初始化colorama
 colorama.init()
 
-os.environ["HF_ENDPOINT"] = "https://hf-mirror.com"
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
+os.environ["HF_ENDPOINT"] = "https://hf-mirror.com"
+
+current_agent = []
+
+def add_agent(agent_name: str):
+    current_agent.append(agent_name)
+
+def get_current_agent():
+    return current_agent[-1] if current_agent else "No Agent"
+
+def delete_current_agent():
+    current_agent.pop()
 
 class OutputType(Enum):
     SYSTEM = "system"      # AI assistant message
@@ -94,7 +109,7 @@ class PrettyOutput:
         prefix = PrettyOutput.PREFIXES.get(output_type, "")
         
         # 添加时间戳 - 使用白色
-        time_str = f"{Fore.WHITE}[{datetime.now().strftime('%H:%M:%S')}]{ColoramaStyle.RESET_ALL} " if timestamp else ""
+        time_str = f"{Fore.BLUE}[{get_current_agent()}]{ColoramaStyle.RESET_ALL}{Fore.WHITE}[{datetime.now().strftime('%H:%M:%S')}]{ColoramaStyle.RESET_ALL} " if timestamp else ""
         
         # 格式化输出
         formatted_text = f"{time_str}{color}{icon} {prefix}: {text}{ColoramaStyle.RESET_ALL}"
@@ -112,10 +127,10 @@ class PrettyOutput:
     @staticmethod
     def section(title: str, output_type: OutputType = OutputType.INFO):
         """Print paragraph title with separator"""
-        width = 60
+        width = 100
         color = PrettyOutput.COLORS.get(output_type, "")
         print(f"\n{color}" + "=" * width + f"{ColoramaStyle.RESET_ALL}")
-        PrettyOutput.print(title.center(width - 10), output_type, timestamp=True)
+        PrettyOutput.print(title.center(width - 25), output_type, timestamp=False)
         print(f"{color}" + "=" * width + f"{ColoramaStyle.RESET_ALL}\n")
 
     @staticmethod
@@ -131,6 +146,14 @@ class PrettyOutput:
         sys.stdout.write("\n")
         sys.stdout.flush()
 
+def get_single_line_input(tip: str) -> str:
+    """Get single line input, support direction key, history function, etc."""
+    session = PromptSession(history=None)
+    style = PromptStyle.from_dict({
+        'prompt': 'ansicyan',
+    })
+    return session.prompt(f"{tip}", style=style)
+
 def get_multiline_input(tip: str) -> str:
     """Get multi-line input, support direction key, history function, etc."""
     print(f"{Fore.GREEN}{tip}{ColoramaStyle.RESET_ALL}")
@@ -171,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:
@@ -187,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):
@@ -217,59 +245,64 @@ def find_git_root(dir="."):
     return ret
 
 def load_embedding_model():
-    model_name = "BAAI/bge-large-zh-v1.5"
-    PrettyOutput.print(f"Loading embedding model: {model_name}...", OutputType.INFO)
+    model_name = "BAAI/bge-m3"
+    cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
+    
+
     try:
-        # 首先尝试离线加载
+        # Load model
         embedding_model = SentenceTransformer(
             model_name,
-            cache_folder=os.path.expanduser("~/.cache/huggingface/hub"),
+            cache_folder=cache_dir,
             local_files_only=True
         )
-        PrettyOutput.print("Successfully loaded model using local cache", OutputType.SUCCESS)
-    except Exception as local_error:
-        PrettyOutput.print(f"Failed to load locally, trying to download online: {str(local_error)}", OutputType.WARNING)
-        # 如果离线加载失败，尝试在线下载
+    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=os.path.expanduser("~/.cache/huggingface/hub")
+            cache_folder=cache_dir,
+            local_files_only=True
         )
-        PrettyOutput.print("Successfully downloaded and loaded model", OutputType.SUCCESS)
     
     return embedding_model
 
 def load_rerank_model():
     """Load reranking model"""
     model_name = "BAAI/bge-reranker-v2-m3"
+    cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
+    
     PrettyOutput.print(f"Loading reranking model: {model_name}...", OutputType.INFO)
     
     try:
-        # 首先尝试离线加载
+        # Load model and tokenizer
         tokenizer = AutoTokenizer.from_pretrained(
             model_name,
-            local_files_only=True,
-            cache_dir=os.path.expanduser("~/.cache/huggingface/hub")
+            cache_dir=cache_dir,
+            local_files_only=True
         )
         model = AutoModelForSequenceClassification.from_pretrained(
             model_name,
-            local_files_only=True,
-            cache_dir=os.path.expanduser("~/.cache/huggingface/hub")
+            cache_dir=cache_dir,
+            local_files_only=True
         )
-        PrettyOutput.print("Successfully loaded model using local cache", OutputType.SUCCESS)
-    except Exception as local_error:
-        PrettyOutput.print(f"Failed to load locally, trying to download online: {str(local_error)}", OutputType.WARNING)
-        # 如果离线加载失败，尝试在线下载
+    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=os.path.expanduser("~/.cache/huggingface/hub")
+            cache_dir=cache_dir,
+            local_files_only=True
         )
         model = AutoModelForSequenceClassification.from_pretrained(
             model_name,
-            cache_dir=os.path.expanduser("~/.cache/huggingface/hub")
+            cache_dir=cache_dir,
+            local_files_only=True
         )
-        PrettyOutput.print("Successfully downloaded and loaded model", OutputType.SUCCESS)
     
-    # 如果有 GPU 就使用 GPU
+    # Use GPU if available
     if torch.cuda.is_available():
         model = model.cuda()
     model.eval()
@@ -303,4 +336,94 @@ 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()
+    return hashlib.md5(open(filepath, "rb").read(100*1024*1024)).hexdigest()
+
+
+def _create_methodology_embedding(embedding_model: Any, methodology_text: str) -> np.ndarray:
+    """Create embedding vector for methodology text"""
+    try:
+        # Truncate long text
+        max_length = 512
+        text = ' '.join(methodology_text.split()[:max_length])
+        
+        # 使用sentence_transformers模型获取嵌入向量
+        embedding = embedding_model.encode([text], 
+                                                convert_to_tensor=True,
+                                                normalize_embeddings=True)
+        vector = np.array(embedding.cpu().numpy(), dtype=np.float32)
+        return vector[0]  # Return first vector, because we only encoded one text
+    except Exception as e:
+        PrettyOutput.print(f"Failed to create methodology embedding vector: {str(e)}", OutputType.ERROR)
+        return np.zeros(1536, dtype=np.float32)
+
+
+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")
+    if not os.path.exists(user_jarvis_methodology):
+        return ""
+
+    try:
+        with open(user_jarvis_methodology, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+
+        # Reset data structure
+        methodology_data = []
+        vectors = []
+        ids = []
+
+        # Get embedding model
+        embedding_model = load_embedding_model()
+        
+        # Create test embedding to get correct dimension
+        test_embedding = _create_methodology_embedding(embedding_model, "test")
+        embedding_dimension = len(test_embedding)
+
+        # Create embedding vector for each methodology
+        for i, (key, value) in enumerate(data.items()):
+            PrettyOutput.print(f"Vectorizing methodology: {key} ...", OutputType.INFO)
+            methodology_text = f"{key}\n{value}"
+            embedding = _create_methodology_embedding(embedding_model, methodology_text)
+            vectors.append(embedding)
+            ids.append(i)
+            methodology_data.append({"key": key, "value": value})
+
+        if vectors:
+            vectors_array = np.vstack(vectors)
+            # Use correct dimension from test embedding
+            hnsw_index = faiss.IndexHNSWFlat(embedding_dimension, 16)
+            hnsw_index.hnsw.efConstruction = 40
+            hnsw_index.hnsw.efSearch = 16
+            methodology_index = faiss.IndexIDMap(hnsw_index)
+            methodology_index.add_with_ids(vectors_array, np.array(ids)) # type: ignore
+            query_embedding = _create_methodology_embedding(embedding_model, user_input)
+            k = min(5, len(methodology_data))
+            PrettyOutput.print(f"Retrieving methodology...", OutputType.INFO)
+            distances, indices = methodology_index.search(
+                query_embedding.reshape(1, -1), k
+            ) # type: ignore
+
+            relevant_methodologies = {}
+            for dist, idx in zip(distances[0], indices[0]):
+                if idx >= 0:
+                    similarity = 1.0 / (1.0 + float(dist))
+                    methodology = methodology_data[idx]
+                    PrettyOutput.print(
+                        f"Methodology '{methodology['key']}' similarity: {similarity:.3f}",
+                        OutputType.INFO
+                    )
+                    if similarity >= 0.5:
+                        relevant_methodologies[methodology["key"]] = methodology["value"]
+                    
+            if relevant_methodologies:
+                return f"""This is the standard methodology for handling previous problems, if the current task is similar, you can refer to it:
+                        {relevant_methodologies}
+                        """
+        return ""
+
+    except Exception as e:
+        PrettyOutput.print(f"Error loading methodology: {str(e)}", OutputType.ERROR)
+        import traceback
+        PrettyOutput.print(f"Error trace: {traceback.format_exc()}", OutputType.INFO)
+        return ""

{jarvis_ai_assistant-0.1.98.dist-info → jarvis_ai_assistant-0.1.100.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jarvis-ai-assistant
-Version: 0.1.98
+Version: 0.1.100
 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.100.dist-info/RECORD

@@ -0,0 +1,51 @@
+jarvis/__init__.py,sha256=CCLUaAlEVc1W7PRJT3CV9kBGq5ZA-5WXMJMM1wOz6jk,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=zTCjei1rv00-iA2zTh4UlJYEZka_AoCsgisAWA5PDug,14803
+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.100.dist-info/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
+jarvis_ai_assistant-0.1.100.dist-info/METADATA,sha256=Q7gLFWY8g_jky5kbsJ9F1YVeBloi1hqQoTKDdF9K9AU,12783
+jarvis_ai_assistant-0.1.100.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+jarvis_ai_assistant-0.1.100.dist-info/entry_points.txt,sha256=x0jA_mYRc7hBVdLuOFQBYQjpXjf8NPrAn0C54DJ9t2I,387
+jarvis_ai_assistant-0.1.100.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
+jarvis_ai_assistant-0.1.100.dist-info/RECORD,,

{jarvis_ai_assistant-0.1.98.dist-info → jarvis_ai_assistant-0.1.100.dist-info}/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
-jarvis = jarvis.main:main
+jarvis = jarvis.agent:main
+jarvis-code-agent = jarvis.jarvis_code_agent.main:main
 jarvis-codebase = jarvis.jarvis_codebase.main:main
 jarvis-coder = jarvis.jarvis_coder.main:main
 jarvis-platform = jarvis.jarvis_platform.main:main

jarvis/main.py

@@ -1,155 +0,0 @@
-#!/usr/bin/env python3
-"""Command line interface for Jarvis."""
-
-import argparse
-import yaml
-import os
-import sys
-from pathlib import Path
-from prompt_toolkit import prompt
-
-from jarvis.models.registry import PlatformRegistry
-
-# Add parent directory to Python path to support imports    
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from jarvis.agent import Agent
-from jarvis.tools import ToolRegistry
-from jarvis.utils import PrettyOutput, OutputType, get_multiline_input, load_env_from_file
-
-
-def load_tasks() -> dict:
-    """Load tasks from .jarvis files in user home and current directory."""
-    tasks = {}
-    
-    # Check .jarvis in user directory
-    user_jarvis = os.path.expanduser("~/.jarvis")
-    if os.path.exists(user_jarvis):
-        try:
-            with open(user_jarvis, "r", encoding="utf-8") as f:
-                user_tasks = yaml.safe_load(f)
-                
-            if isinstance(user_tasks, dict):
-                # Validate and add user directory tasks
-                for name, desc in user_tasks.items():
-                    if desc:  # Ensure description is not empty
-                        tasks[str(name)] = str(desc)
-            else:
-                PrettyOutput.print("Warning: ~/.jarvis file should contain a dictionary of task_name: task_description", OutputType.ERROR)
-        except Exception as e:
-            PrettyOutput.print(f"Error loading ~/.jarvis file: {str(e)}", OutputType.ERROR)
-    
-    # Check .jarvis in current directory
-    if os.path.exists(".jarvis"):
-        try:
-            with open(".jarvis", "r", encoding="utf-8") as f:
-                local_tasks = yaml.safe_load(f)
-                
-            if isinstance(local_tasks, dict):
-                # Validate and add current directory tasks, overwrite user directory tasks if there is a name conflict
-                for name, desc in local_tasks.items():
-                    if desc:  # Ensure description is not empty
-                        tasks[str(name)] = str(desc)
-            else:
-                PrettyOutput.print("Warning: .jarvis file should contain a dictionary of task_name: task_description", OutputType.ERROR)
-        except Exception as e:
-            PrettyOutput.print(f"Error loading .jarvis file: {str(e)}", OutputType.ERROR)
-
-    # Read methodology
-    method_path = os.path.expanduser("~/.jarvis_methodology")
-    if os.path.exists(method_path):
-        with open(method_path, "r", encoding="utf-8") as f:
-            methodology = yaml.safe_load(f)
-        if isinstance(methodology, dict):
-            for name, desc in methodology.items():
-                tasks[f"Run Methodology: {str(name)}\n {str(desc)}" ] = str(desc)
-    
-    return tasks
-
-def select_task(tasks: dict) -> str:
-    """Let user select a task from the list or skip. Returns task description if selected."""
-    if not tasks:
-        return ""
-    
-    # Convert tasks to list for ordered display
-    task_names = list(tasks.keys())
-    
-    PrettyOutput.print("\nAvailable tasks:", OutputType.INFO)
-    for i, name in enumerate(task_names, 1):
-        PrettyOutput.print(f"[{i}] {name}", OutputType.INFO)
-    PrettyOutput.print("[0] Skip predefined tasks", OutputType.INFO)
-    
-    
-    while True:
-        try:
-            choice = prompt(
-                "\nPlease select a task number (0 to skip): ",
-            ).strip()
-            
-            if not choice:
-                return ""
-            
-            choice = int(choice)
-            if choice == 0:
-                return ""
-            elif 1 <= choice <= len(task_names):
-                selected_name = task_names[choice - 1]
-                return tasks[selected_name]  # Return the task description
-            else:
-                PrettyOutput.print("Invalid choice. Please select a number from the list.", OutputType.ERROR)
-                
-        except KeyboardInterrupt:
-            return ""  # Return empty on Ctrl+C
-        except EOFError:
-            return ""  # Return empty on Ctrl+D
-        except Exception as e:
-            PrettyOutput.print(f"Failed to select task: {str(e)}", OutputType.ERROR)
-            continue
-
-def main():
-    """Jarvis main entry point"""
-    # Add argument parser
-    load_env_from_file()
-    parser = argparse.ArgumentParser(description='Jarvis AI assistant')
-    parser.add_argument('-f', '--files', nargs='*', help='List of files to process')
-    parser.add_argument('--keep-history', action='store_true', help='Keep chat history (do not delete session)')
-    args = parser.parse_args()
-
-    try:
-        # 获取全局模型实例
-        agent = Agent()
-
-        # 如果用户传入了模型参数，则更换当前模型为用户指定的模型
-
-        # Welcome information
-        PrettyOutput.print(f"Jarvis initialized - With {agent.model.name()}", OutputType.SYSTEM)
-        if args.keep_history:
-            PrettyOutput.print("History preservation mode enabled", OutputType.INFO)
-        
-        # 加载预定义任务
-        tasks = load_tasks()
-        if tasks:
-            selected_task = select_task(tasks)
-            if selected_task:
-                PrettyOutput.print(f"\nExecute task: {selected_task}", OutputType.INFO)
-                agent.run(selected_task, args.files)
-                return 0
-        
-        # 如果没有选择预定义任务，进入交互模式
-        while True:
-            try:
-                user_input = get_multiline_input("Please enter your task (input empty line to exit):")
-                if not user_input or user_input == "__interrupt__":
-                    break
-                agent.run(user_input, args.files)
-            except Exception as e:
-                PrettyOutput.print(f"Error: {str(e)}", OutputType.ERROR)
-
-    except Exception as e:
-        PrettyOutput.print(f"Initialization error: {str(e)}", OutputType.ERROR)
-        return 1
-
-    return 0
-
-if __name__ == "__main__":
-    exit(main())

jarvis/tools/codebase_qa.py

@@ -1,74 +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:
-    """代码库问答工具，用于回答关于代码库的问题"""
-    
-    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]:
-        """执行代码问答"""
-        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": "错误：当前目录不在Git仓库中",
-                    "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"代码问答出错: {str(e)}", output_type=OutputType.ERROR)
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"执行代码问答时发生错误: {str(e)}",
-                "error": str(type(e).__name__)
-            }
-
-def register():
-    return CodebaseQATool()