jarvis-ai-assistant 0.1.73__tar.gz → 0.1.75__tar.gz

{jarvis_ai_assistant-0.1.73/src/jarvis_ai_assistant.egg-info → jarvis_ai_assistant-0.1.75}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jarvis-ai-assistant
-Version: 0.1.73
+Version: 0.1.75
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire

{jarvis_ai_assistant-0.1.73 → jarvis_ai_assistant-0.1.75}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "jarvis-ai-assistant"
-version = "0.1.73"
+version = "0.1.75"
 description = "Jarvis: An AI assistant that uses tools to interact with the system"
 readme = "README.md"
 authors = [{ name = "Your Name", email = "your.email@example.com" }]

{jarvis_ai_assistant-0.1.73 → jarvis_ai_assistant-0.1.75}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="jarvis-ai-assistant",
-    version="0.1.73",
+    version="0.1.75",
     author="skyfire",
     author_email="skyfireitdiy@hotmail.com",
     description="An AI assistant that uses various tools to interact with the system",

{jarvis_ai_assistant-0.1.73 → jarvis_ai_assistant-0.1.75}/src/jarvis/__init__.py

@@ -1,3 +1,3 @@
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.73" 
+__version__ = "0.1.75" 

{jarvis_ai_assistant-0.1.73 → jarvis_ai_assistant-0.1.75}/src/jarvis/agent.py

@@ -2,6 +2,9 @@ import time
 from typing import Dict, List, Optional
 
 import yaml
+import numpy as np
+import faiss
+import json
 
 from .models.registry import PlatformRegistry
 from .tools import ToolRegistry
@@ -9,6 +12,7 @@ from .utils import PrettyOutput, OutputType, get_multiline_input, while_success
 import os
 from datetime import datetime
 from prompt_toolkit import prompt
+from sentence_transformers import SentenceTransformer
 
 class Agent:
     def __init__(self, name: str = "Jarvis", is_sub_agent: bool = False):
@@ -26,7 +30,37 @@ class Agent:
         self.is_sub_agent = is_sub_agent
         self.prompt = ""
         self.conversation_turns = 0  
-
+        
+        # 从环境变量加载嵌入模型配置
+        self.embedding_model_name = os.environ.get("JARVIS_EMBEDDING_MODEL", "BAAI/bge-large-zh-v1.5")
+        self.embedding_dimension = 1536  # Default for many embedding models
+        
+        # 初始化嵌入模型
+        try:
+            os.environ["TOKENIZERS_PARALLELISM"] = "false"
+            PrettyOutput.print(f"正在加载嵌入模型: {self.embedding_model_name}...", OutputType.INFO)
+            self.embedding_model = SentenceTransformer(self.embedding_model_name)
+            
+            # 预热模型并获取正确的维度
+            test_text = "这是一段测试文本，用于确保模型完全加载。"
+            test_embedding = self.embedding_model.encode(test_text, 
+                                                      convert_to_tensor=True,
+                                                      normalize_embeddings=True)
+            self.embedding_dimension = len(test_embedding)
+            PrettyOutput.print("嵌入模型加载完成", OutputType.SUCCESS)
+            
+            # 初始化HNSW索引（使用正确的维度）
+            hnsw_index = faiss.IndexHNSWFlat(self.embedding_dimension, 16)
+            hnsw_index.hnsw.efConstruction = 40
+            hnsw_index.hnsw.efSearch = 16
+            self.methodology_index = faiss.IndexIDMap(hnsw_index)
+            
+        except Exception as e:
+            PrettyOutput.print(f"加载嵌入模型失败: {str(e)}", OutputType.ERROR)
+            raise
+            
+        # 初始化方法论相关属性
+        self.methodology_data = []
 
     @staticmethod
     def extract_tool_calls(content: str) -> List[Dict]:
@@ -87,16 +121,77 @@ class Agent:
                     sleep_time = 30
                 continue
 
+    def _create_methodology_embedding(self, methodology_text: str) -> np.ndarray:
+        """为方法论文本创建嵌入向量"""
+        try:
+            # 对长文本进行截断
+            max_length = 512
+            text = ' '.join(methodology_text.split()[:max_length])
+            
+            # 使用sentence_transformers模型获取嵌入向量
+            embedding = self.embedding_model.encode([text], 
+                                                 convert_to_tensor=True,
+                                                 normalize_embeddings=True)
+            vector = np.array(embedding, dtype=np.float32)
+            return vector[0]  # 返回第一个向量，因为我们只编码了一个文本
+        except Exception as e:
+            PrettyOutput.print(f"创建方法论嵌入向量失败: {str(e)}", OutputType.ERROR)
+            return np.zeros(self.embedding_dimension, dtype=np.float32)
 
-    def _load_methodology(self) -> Dict[str, str]:
-        """加载方法论"""
+    def _load_methodology(self, user_input: str) -> Dict[str, str]:
+        """加载方法论并构建向量索引"""
         user_jarvis_methodology = os.path.expanduser("~/.jarvis_methodology")
-        if os.path.exists(user_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)
-            PrettyOutput.print(f"从 {user_jarvis_methodology} 加载方法论: {', '.join(data.keys())}", OutputType.INFO)
-            return data
-        return {}
+
+            # 重置数据结构
+            self.methodology_data = []
+            vectors = []
+            ids = []
+
+            # 为每个方法论创建嵌入向量
+            for i, (key, value) in enumerate(data.items()):
+                PrettyOutput.print(f"向量化方法论: {key} ...", OutputType.INFO)
+                methodology_text = f"{key}\n{value}"
+                embedding = self._create_methodology_embedding(methodology_text)
+                vectors.append(embedding)
+                ids.append(i)
+                self.methodology_data.append({"key": key, "value": value})
+
+            if vectors:
+                vectors_array = np.vstack(vectors)
+                self.methodology_index.add_with_ids(vectors_array, np.array(ids))
+                query_embedding = self._create_methodology_embedding(user_input)
+                k = min(5, len(self.methodology_data))
+                PrettyOutput.print(f"检索方法论...", OutputType.INFO)
+                distances, indices = self.methodology_index.search(
+                    query_embedding.reshape(1, -1), k
+                )
+
+                relevant_methodologies = {}
+                for dist, idx in zip(distances[0], indices[0]):
+                    if idx >= 0:
+                        similarity = 1.0 / (1.0 + float(dist))
+                        methodology = self.methodology_data[idx]
+                        PrettyOutput.print(
+                            f"方法论 '{methodology['key']}' 相似度: {similarity:.3f}",
+                            OutputType.INFO
+                        )
+                        if similarity >= 0.5:
+                            relevant_methodologies[methodology["key"]] = methodology["value"]
+                        
+                if relevant_methodologies:
+                    return relevant_methodologies
+
+            return {}
+
+        except Exception as e:
+            PrettyOutput.print(f"加载方法论时发生错误: {str(e)}", OutputType.ERROR)
+            return {}
 
     def _summarize_and_clear_history(self) -> None:
         """总结当前对话历史并清空历史记录，只保留系统消息和总结
@@ -211,7 +306,7 @@ class Agent:
                 self.model.upload_files(file_list)
 
             # 加载方法论
-            methodology = self._load_methodology()
+            methodology = self._load_methodology(user_input)
             methodology_prompt = ""
             if methodology:
                 methodology_prompt = f"""这是以往处理问题的标准方法论，如果当前任务与此类似，可参考：
@@ -277,6 +372,7 @@ arguments:
 6. 处理问题的每个步骤不是必须有的，可按情况省略
 7. 在执行一些可能对系统或者用户代码库造成破坏的工具时，请先询问用户
 8. 在多次迭代却没有任何进展时，可请求用户指导
+9. 如果返回的yaml字符串中包含冒号，请将整个字符串用引号包裹，避免yaml解析错误
 
 -------------------------------------------------------------
 

{jarvis_ai_assistant-0.1.73 → jarvis_ai_assistant-0.1.75}/src/jarvis/jarvis_codebase/main.py

@@ -310,27 +310,103 @@ class CodeBase:
         self.build_index()
         self.save_cache()
 
-    def generate_codebase(self):
-        """生成代码库索引"""
-        files_deleted = self.clean_cache()  # 清理过期缓存
-        processed_files = []
+
+    def generate_codebase(self, force: bool = False):
+        """生成代码库索引
+        Args:
+            force: 是否强制重建索引，不询问用户
+        """
+        # 更新 git 文件列表
+        self.git_file_list = self.get_git_file_list()
+        
+        # 检查文件变化
+        changes_detected = False
+        new_files = []
+        modified_files = []
+        deleted_files = []
+        
+        # 检查删除的文件
+        files_to_delete = []
+        for file_path in list(self.vector_cache.keys()):
+            if file_path not in self.git_file_list:
+                deleted_files.append(file_path)
+                files_to_delete.append(file_path)
+                changes_detected = True
+        
+        # 检查新增和修改的文件
+        for file_path in self.git_file_list:
+            if not os.path.exists(file_path) or not self.is_text_file(file_path):
+                continue
+            
+            try:
+                current_md5 = hashlib.md5(open(file_path, "rb").read()).hexdigest()
+                
+                if file_path not in self.vector_cache:
+                    new_files.append(file_path)
+                    changes_detected = True
+                elif self.vector_cache[file_path].get("md5") != current_md5:
+                    modified_files.append(file_path)
+                    changes_detected = True
+            except Exception as e:
+                PrettyOutput.print(f"检查文件失败 {file_path}: {str(e)}", 
+                                 output_type=OutputType.ERROR)
+                continue
         
-        # 使用线程池处理文件
-        with ThreadPoolExecutor(max_workers=self.thread_count) as executor:
-            futures = [executor.submit(self.process_file, file) for file in self.git_file_list]
-            for future in concurrent.futures.as_completed(futures):
-                result = future.result()
-                if result:
-                    processed_files.append(result)
-                    PrettyOutput.print(f"索引文件: {result}", output_type=OutputType.INFO)
-
-        if files_deleted or processed_files:
+        # 如果检测到变化，显示变化并询问用户
+        if changes_detected:
+            PrettyOutput.print("\n检测到以下变化:", output_type=OutputType.WARNING)
+            if new_files:
+                PrettyOutput.print("\n新增文件:", output_type=OutputType.INFO)
+                for f in new_files:
+                    PrettyOutput.print(f"  {f}", output_type=OutputType.INFO)
+            if modified_files:
+                PrettyOutput.print("\n修改的文件:", output_type=OutputType.INFO)
+                for f in modified_files:
+                    PrettyOutput.print(f"  {f}", output_type=OutputType.INFO)
+            if deleted_files:
+                PrettyOutput.print("\n删除的文件:", output_type=OutputType.INFO)
+                for f in deleted_files:
+                    PrettyOutput.print(f"  {f}", output_type=OutputType.INFO)
+            
+
+            # 如果force为True，直接继续
+            if not force:
+                # 询问用户是否继续
+                while True:
+                    response = input("\n是否重建索引？[y/N] ").lower().strip()
+                    if response in ['y', 'yes']:
+                        break
+                    elif response in ['', 'n', 'no']:
+                        PrettyOutput.print("取消重建索引", output_type=OutputType.INFO)
+                        return
+                    else:
+                        PrettyOutput.print("请输入 y 或 n", output_type=OutputType.WARNING)
+            
+            # 清理已删除的文件
+            for file_path in files_to_delete:
+                del self.vector_cache[file_path]
+            if files_to_delete:
+                PrettyOutput.print(f"清理了 {len(files_to_delete)} 个文件的缓存", 
+                                 output_type=OutputType.INFO)
+            
+            # 处理新文件和修改的文件
+            processed_files = []
+            files_to_process = new_files + modified_files
+            
+            # 使用线程池处理文件
+            with ThreadPoolExecutor(max_workers=self.thread_count) as executor:
+                futures = [executor.submit(self.process_file, file) for file in files_to_process]
+                for future in concurrent.futures.as_completed(futures):
+                    result = future.result()
+                    if result:
+                        processed_files.append(result)
+                        PrettyOutput.print(f"索引文件: {result}", output_type=OutputType.INFO)
+
             PrettyOutput.print("重新生成向量数据库", output_type=OutputType.INFO)
             self.gen_vector_db_from_cache()
+            PrettyOutput.print(f"成功为 {len(processed_files)} 个文件生成索引", output_type=OutputType.INFO)
         else:
-            PrettyOutput.print("没有新的文件变更，跳过向量数据库生成", output_type=OutputType.INFO)
-            
-        PrettyOutput.print(f"成功为 {len(processed_files)} 个文件生成索引", output_type=OutputType.INFO)
+            PrettyOutput.print("没有检测到文件变更，无需重建索引", output_type=OutputType.INFO)
 
     def rerank_results(self, query: str, initial_results: List[Tuple[str, float, str]]) -> List[Tuple[str, float, str]]:
         """使用大模型对搜索结果重新排序"""
@@ -488,6 +564,31 @@ class CodeBase:
         finally:
             model.delete_chat()
 
+    def is_index_generated(self) -> bool:
+        """检查索引是否已经生成"""
+        # 检查缓存文件是否存在
+        if not os.path.exists(self.cache_path):
+            return False
+        
+        # 检查缓存是否有效
+        try:
+            with open(self.cache_path, 'rb') as f:
+                cache_data = pickle.load(f)
+                if not cache_data.get("vectors") or not cache_data.get("file_paths"):
+                    return False
+        except Exception:
+            return False
+        
+        # 检查索引是否已构建
+        if not hasattr(self, 'index') or self.index is None:
+            return False
+        
+        # 检查向量缓存和文件路径列表是否非空
+        if not self.vector_cache or not self.file_paths:
+            return False
+        
+        return True
+
 
 
 def main():
@@ -501,10 +602,15 @@ def main():
     current_dir = find_git_root()
     codebase = CodeBase(current_dir)
 
+    # 如果没有生成索引，且不是生成命令，提示用户先生成索引
+    if not codebase.is_index_generated() and not args.generate:
+        PrettyOutput.print("索引尚未生成，请先运行 --generate 生成索引", output_type=OutputType.WARNING)
+        return
+
 
     if args.generate:
         try:
-            codebase.generate_codebase()
+            codebase.generate_codebase(force=True)
             PrettyOutput.print("\nCodebase generation completed", output_type=OutputType.SUCCESS)
         except Exception as e:
             PrettyOutput.print(f"Error during codebase generation: {str(e)}", output_type=OutputType.ERROR)

{jarvis_ai_assistant-0.1.73 → jarvis_ai_assistant-0.1.75}/src/jarvis/jarvis_coder/main.py

@@ -278,12 +278,12 @@ class JarvisCoder:
         
         return True, ""
 
-    def _save_edit_record(self, feature: str, patches: List[str]) -> None:
+    def _save_edit_record(self, commit_message: str, git_diff: str) -> None:
         """保存代码修改记录
         
         Args:
-            feature: 需求描述
-            patches: 补丁列表
+            commit_message: 提交信息
+            git_diff: git diff --cached的输出
         """
             
         # 获取下一个序号
@@ -296,8 +296,8 @@ class JarvisCoder:
         # 创建记录文件
         record = {
             "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
-            "feature": feature,
-            "patches": patches
+            "commit_message": commit_message,
+            "git_diff": git_diff
         }
         
         record_path = os.path.join(self.record_dir, f"{next_num:04d}.yaml")
@@ -312,20 +312,7 @@ class JarvisCoder:
     def _prepare_execution(self) -> None:
         """准备执行环境"""
         self.main_model = self._new_model()
-        
-
-        # 询问用户是否更新索引数据库
-        while True:
-            answer = get_multiline_input("是否要更新代码库索引数据库？(y/n)").strip().lower()
-            if answer == 'y':
-                PrettyOutput.print("正在更新代码库索引数据库...", OutputType.PROGRESS)
-                self._codebase.generate_codebase()
-                break
-            elif answer == 'n' or not answer:
-                PrettyOutput.print("跳过代码库索引数据库更新", OutputType.INFO)
-                break
-            else:
-                PrettyOutput.print("请输入 y 或 n", OutputType.WARNING)
+        self._codebase.generate_codebase()
 
 
     def _load_related_files(self, feature: str) -> List[Dict]:
@@ -359,7 +346,7 @@ class JarvisCoder:
             if success:
                 user_confirm = input("是否确认修改？(y/n)")
                 if user_confirm.lower() == "y":
-                    self._finalize_changes(feature, patches)
+                    self._finalize_changes(feature)
                     return {
                         "success": True,
                         "stdout": f"已完成功能开发{feature}",
@@ -389,12 +376,74 @@ class JarvisCoder:
 """
                 patches = self._remake_patch(retry_prompt)
 
-    def _finalize_changes(self, feature: str, patches: List[str]) -> None:
+
+
+
+    def _generate_commit_message(self, git_diff: str, feature: str) -> str:
+        """根据git diff和功能描述生成commit信息
+        
+        Args:
+            git_diff: git diff --cached的输出
+            feature: 用户的功能描述
+            
+        Returns:
+            str: 生成的commit信息
+        """
+        
+        # 生成提示词
+        prompt = f"""你是一个经验丰富的程序员，请根据以下代码变更和功能描述生成简洁明了的commit信息：
+
+功能描述：
+{feature}
+
+代码变更：
+"""
+        # 添加git diff内容
+        prompt += f"Git Diff:\n{git_diff}\n\n"
+            
+        prompt += """
+请遵循以下规则：
+1. 使用英文编写
+2. 采用常规的commit message格式：<type>(<scope>): <subject>
+3. 保持简洁，不超过50个字符
+4. 准确描述代码变更的主要内容
+5. 优先考虑功能描述和git diff中的变更内容
+"""
+        
+        # 使用normal模型生成commit信息
+        model = PlatformRegistry().get_global_platform_registry().create_platform(self.platform)
+        model.set_model_name(self.model)
+        model.set_suppress_output(True)
+        success, response = self._call_model_with_retry(model, prompt)
+        if not success:
+            return "Update code changes"
+            
+        # 清理响应内容
+        return response.strip().split("\n")[0]
+
+    def _finalize_changes(self, feature: str) -> None:
         """完成修改并提交"""
         PrettyOutput.print("修改确认成功，提交修改", OutputType.INFO)
-        os.system(f"git add .")
-        os.system(f"git commit -m '{feature}'")
-        self._save_edit_record(feature, patches)
+
+        # 只添加已经在 git 控制下的修改文件
+        os.system("git add -u")
+        
+        # 然后获取 git diff
+        git_diff = os.popen("git diff --cached").read()
+        
+        # 自动生成commit信息，传入feature
+        commit_message = self._generate_commit_message(git_diff, feature)
+        
+        # 显示并确认commit信息
+        PrettyOutput.print(f"自动生成的commit信息: {commit_message}", OutputType.INFO)
+        user_confirm = input("是否使用该commit信息？(y/n) [y]: ") or "y"
+        
+        if user_confirm.lower() != "y":
+            commit_message = input("请输入新的commit信息: ")
+        
+        # 不需要再次 git add，因为已经添加过了
+        os.system(f"git commit -m '{commit_message}'")
+        self._save_edit_record(commit_message, git_diff)
 
     def _revert_changes(self) -> None:
         """回退所有修改"""

{jarvis_ai_assistant-0.1.73 → jarvis_ai_assistant-0.1.75}/src/jarvis/tools/codebase_qa.py

@@ -49,7 +49,8 @@ class CodebaseQATool:
             os.chdir(root_dir)
             codebase = CodeBase(root_dir)
             # 生成索引
-            codebase.generate_codebase()
+
+            codebase.generate_codebase(force=True)
             # 执行问答
             response = codebase.ask_codebase(question, top_k)
             os.chdir(current_dir)

{jarvis_ai_assistant-0.1.73 → jarvis_ai_assistant-0.1.75/src/jarvis_ai_assistant.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jarvis-ai-assistant
-Version: 0.1.73
+Version: 0.1.75
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire