jarvis-ai-assistant 0.1.58__py3-none-any.whl → 0.1.74__py3-none-any.whl

jarvis/main.py

@@ -117,7 +117,6 @@ def main():
     PlatformRegistry.get_global_platform_registry().set_global_platform_name(platform)
 
     if args.model:
-        PrettyOutput.print(f"用户传入了模型参数，更换模型: {args.model}", OutputType.USER)
         os.environ["JARVIS_MODEL"] = args.model
 
     try:
@@ -126,7 +125,6 @@ def main():
 
         # 如果用户传入了模型参数，则更换当前模型为用户指定的模型
         if args.model:
-            PrettyOutput.print(f"用户传入了模型参数，更换模型: {args.model}", OutputType.USER)
             agent.model.set_model_name(args.model)
 
         # 欢迎信息

jarvis/models/ai8.py

@@ -64,15 +64,14 @@ class AI8Model(BasePlatform):
         
         PrettyOutput.print("使用AI8_MODEL环境变量配置模型", OutputType.SUCCESS)
         
-        self.model_name = os.getenv("AI8_MODEL") or os.getenv("JARVIS_MODEL") or "deepseek-chat"
+        self.model_name = os.getenv("JARVIS_MODEL") or "deepseek-chat"
         if self.model_name not in self.models:
             PrettyOutput.print(f"警告: 当前选择的模型 {self.model_name} 不在可用列表中", OutputType.WARNING)
         
-        PrettyOutput.print(f"当前使用模型: {self.model_name}", OutputType.SYSTEM)
 
     def set_model_name(self, model_name: str):
         """设置模型名称"""
-        PrettyOutput.print(f"设置模型: {model_name}", OutputType.USER)
+
         self.model_name = model_name
             
     def create_conversation(self) -> bool:

jarvis/models/base.py

@@ -42,9 +42,5 @@ class BasePlatform(ABC):
         raise NotImplementedError("set_system_message is not implemented")
 
     def set_suppress_output(self, suppress: bool):
-        """设置是否屏蔽输出
-        
-        Args:
-            suppress: 是否屏蔽输出
-        """
+        """设置是否屏蔽输出"""
         self.suppress_output = suppress

jarvis/models/kimi.py

@@ -360,6 +360,8 @@ class KimiModel(BasePlatform):
                             PrettyOutput.print(f"  原文: {text}", OutputType.PROGRESS)
                     
                     PrettyOutput.print("", OutputType.PROGRESS)
+
+            PrettyOutput.print(full_response, OutputType.RESULT)
             
             return full_response
 

jarvis/models/openai.py

@@ -33,7 +33,6 @@ class OpenAIModel(BasePlatform):
         self.base_url = os.getenv("OPENAI_API_BASE", "https://api.deepseek.com")
         self.model_name = os.getenv("OPENAI_MODEL_NAME") or os.getenv("JARVIS_MODEL") or "deepseek-chat"
 
-        PrettyOutput.print(f"当前使用模型: {self.model_name}", OutputType.SYSTEM)
             
         self.client = OpenAI(
             api_key=self.api_key,
@@ -44,7 +43,7 @@ class OpenAIModel(BasePlatform):
 
     def set_model_name(self, model_name: str):
         """设置模型名称"""
-        PrettyOutput.print(f"设置模型: {model_name}", OutputType.USER)
+
         self.model_name = model_name
 
     def set_system_message(self, message: str):

jarvis/models/oyi.py

@@ -25,8 +25,6 @@ class OyiModel(BasePlatform):
         else:
             PrettyOutput.print("获取模型列表失败", OutputType.WARNING)
         
-        PrettyOutput.print("使用OYI_MODEL环境变量配置模型", OutputType.SUCCESS)
-        
         self.messages = []
         self.system_message = ""
         self.conversation = None
@@ -37,15 +35,14 @@ class OyiModel(BasePlatform):
         if not self.token:
             raise Exception("OYI_API_KEY is not set")
         
-        self.model_name = os.getenv("OYI_MODEL") or os.getenv("JARVIS_MODEL") or "deepseek-chat"
+        self.model_name = os.getenv("JARVIS_MODEL") or "deepseek-chat"
         if self.model_name not in [m.split()[0] for m in available_models]:
             PrettyOutput.print(f"警告: 当前选择的模型 {self.model_name} 不在可用列表中", OutputType.WARNING)
         
-        PrettyOutput.print(f"当前使用模型: {self.model_name}", OutputType.SYSTEM)
 
     def set_model_name(self, model_name: str):
         """设置模型名称"""
-        PrettyOutput.print(f"设置模型: {model_name}", OutputType.USER)
+
         self.model_name = model_name
 
         

jarvis/models/registry.py

@@ -29,7 +29,8 @@ class PlatformRegistry:
                 # 创建 __init__.py 使其成为 Python 包
                 with open(os.path.join(user_platform_dir, "__init__.py"), "w") as f:
                     pass
-                PrettyOutput.print(f"已创建平台目录: {user_platform_dir}", OutputType.INFO)
+
+                pass
             except Exception as e:
                 PrettyOutput.print(f"创建平台目录失败: {str(e)}", OutputType.ERROR)
                 return ""
@@ -81,7 +82,7 @@ class PlatformRegistry:
             directory: 平台目录路径
             
         Returns:
-            Dict[str, Type[BaseModel]]: 平台名称到平台类的映射
+            Dict[str, Type[BasePlatform]]: 平台名称到平台类的映射
         """
         platforms = {}
         
@@ -112,7 +113,7 @@ class PlatformRegistry:
                     
                     # 遍历模块中的所有类
                     for name, obj in inspect.getmembers(module):
-                        # 检查是否是BaseModel的子类，但不是BaseModel本身
+                        # 检查是否是BasePlatform的子类，但不是BasePlatform本身
                         if (inspect.isclass(obj) and 
                             issubclass(obj, BasePlatform) and 
                             obj != BasePlatform and
@@ -120,8 +121,8 @@ class PlatformRegistry:
                             # 检查平台实现
                             if not PlatformRegistry.check_platform_implementation(obj):
                                 continue
+                            PrettyOutput.print(f"从 {os.path.join(directory, filename)} 加载平台：{obj.platform_name}", OutputType.SUCCESS)
                             platforms[obj.platform_name] = obj
-                            PrettyOutput.print(f"从 {directory} 加载平台: {obj.platform_name}", OutputType.INFO)
                             break
                 except Exception as e:
                     PrettyOutput.print(f"加载平台 {module_name} 失败: {str(e)}", OutputType.ERROR)
@@ -159,6 +160,7 @@ class PlatformRegistry:
             raise Exception(f"Failed to create platform: {PlatformRegistry.global_platform_name}")
         return platform
         
+
     def register_platform(self, name: str, platform_class: Type[BasePlatform]):
         """注册平台类
         
@@ -167,7 +169,6 @@ class PlatformRegistry:
             model_class: 平台类
         """
         self.platforms[name] = platform_class
-        PrettyOutput.print(f"已注册平台: {name}", OutputType.INFO)
             
     def create_platform(self, name: str) -> Optional[BasePlatform]:
         """创建平台实例
@@ -176,15 +177,15 @@ class PlatformRegistry:
             name: 平台名称
             
         Returns:
-            BaseModel: 平台实例
+            BasePlatform: 平台实例
         """
         if name not in self.platforms:
             PrettyOutput.print(f"未找到平台: {name}", OutputType.ERROR)
             return None
             
         try:
+
             platform = self.platforms[name]()
-            PrettyOutput.print(f"已创建平台实例: {name}", OutputType.INFO)
             return platform
         except Exception as e:
             PrettyOutput.print(f"创建平台失败: {str(e)}", OutputType.ERROR)

jarvis/tools/__init__.py

@@ -3,3 +3,4 @@ from .registry import ToolRegistry
 __all__ = [
     'ToolRegistry',
 ] 
+

jarvis/tools/codebase_qa.py

@@ -0,0 +1,74 @@
+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 = "回答关于代码库的问题，可以查询和理解代码的功能、结构和实现细节"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "dir": {
+                "type": "string",
+                "description": "项目根目录"
+            },
+            "question": {
+                "type": "string",
+                "description": "关于代码库的问题"
+            },
+            "top_k": {
+                "type": "integer",
+                "description": "搜索相关文件的数量",
+                "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(force=True)
+            # 执行问答
+            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() 

jarvis/tools/coder.py

@@ -0,0 +1,69 @@
+import os
+from typing import Dict, Any, Optional
+from jarvis.jarvis_coder.main import JarvisCoder
+from jarvis.utils import PrettyOutput, OutputType
+
+class CoderTool:
+    """代码修改工具"""
+    
+    name = "coder"
+    description = "用于自动修改和生成代码的工具"
+    parameters = {
+        "feature": {
+            "type": "string",
+            "description": "要实现的功能描述",
+            "required": True
+        },
+        "dir": {
+            "type": "string", 
+            "description": "项目根目录",
+            "required": False
+        },
+        "language": {
+            "type": "string",
+            "description": "编程语言",
+            "required": False
+        }
+    }
+
+    def __init__(self):
+        self._coder = None
+
+
+    def _init_coder(self, dir: Optional[str] = None, language: Optional[str] = "python") -> None:
+        """初始化JarvisCoder实例"""
+        if not self._coder:
+            import os
+            work_dir = dir or os.getcwd()
+            self._coder = JarvisCoder(work_dir, language)
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """执行代码修改
+        
+        Args:
+            feature: 要实现的功能描述
+            dir: 可选，项目根目录
+            language: 可选，编程语言
+            
+        Returns:
+            Dict[str, Any]: 执行结果
+        """
+        feature = args.get("feature")
+        dir = args.get("dir")
+        language = args.get("language", "python")
+        
+        try:
+            self.current_dir = os.getcwd()
+            self._init_coder(dir, language)
+            result = self._coder.execute(feature)
+            return result
+        except Exception as e:
+            PrettyOutput.print(f"代码修改失败: {str(e)}", OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"执行失败: {str(e)}",
+                "error": e
+            } 
+        finally:
+            os.chdir(self.current_dir)

jarvis/tools/methodology.py

@@ -8,7 +8,7 @@ class MethodologyTool:
     """经验管理工具"""
     
     name = "methodology"
-    description = "管理问题处理经验总结，支持添加、更新、删除操作"
+    description = "管理问题处理方法论，支持添加、更新、删除操作"
     parameters = {
         "type": "object",
         "properties": {
@@ -23,7 +23,7 @@ class MethodologyTool:
             },
             "content": {
                 "type": "string",
-                "description": "经验总结内容 (update/add 时必需)",
+                "description": "方法论内容 (update/add 时必需)",
                 "optional": True
             }
         },
@@ -36,39 +36,39 @@ class MethodologyTool:
         self._ensure_file_exists()
             
     def _ensure_file_exists(self):
-        """确保经验总结文件存在"""
+        """确保方法论文件存在"""
         if not os.path.exists(self.methodology_file):
             try:
                 with open(self.methodology_file, 'w', encoding='utf-8') as f:
                     yaml.safe_dump({}, f, allow_unicode=True)
             except Exception as e:
-                PrettyOutput.print(f"创建经验总结文件失败: {str(e)}", OutputType.ERROR)
+                PrettyOutput.print(f"创建方法论文件失败: {str(e)}", OutputType.ERROR)
                 
     def _load_methodologies(self) -> Dict:
-        """加载所有经验总结"""
+        """加载所有方法论"""
         try:
             with open(self.methodology_file, 'r', encoding='utf-8') as f:
                 return yaml.safe_load(f) or {}
         except Exception as e:
-            PrettyOutput.print(f"加载经验总结失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"加载方法论失败: {str(e)}", OutputType.ERROR)
             return {}
             
     def _save_methodologies(self, methodologies: Dict):
-        """保存所有经验总结"""
+        """保存所有方法论"""
         try:
             with open(self.methodology_file, 'w', encoding='utf-8') as f:
                 yaml.safe_dump(methodologies, f, allow_unicode=True)
         except Exception as e:
-            PrettyOutput.print(f"保存经验总结失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"保存方法论失败: {str(e)}", OutputType.ERROR)
             
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-        """执行经验总结管理操作
+        """执行方法论管理操作
         
         Args:
             args: 包含操作参数的字典
                 - operation: 操作类型 (delete/update/add)
                 - problem_type: 问题类型
-                - content: 经验总结内容 (update/add 时必需)
+                - content: 方法论内容 (update/add 时必需)
             
         Returns:
             Dict[str, Any]: 包含执行结果的字典
@@ -92,19 +92,19 @@ class MethodologyTool:
                     self._save_methodologies(methodologies)
                     return {
                         "success": True,
-                        "stdout": f"已删除问题类型 '{problem_type}' 的经验总结"
+                        "stdout": f"已删除问题类型 '{problem_type}' 的方法论"
                     }
                 else:
                     return {
                         "success": False,
-                        "error": f"未找到问题类型 '{problem_type}' 的经验总结"
+                        "error": f"未找到问题类型 '{problem_type}' 的方法论"
                     }
                     
             elif operation in ["update", "add"]:
                 if not content:
                     return {
                         "success": False,
-                        "error": "需要提供经验总结内容"
+                        "error": "需要提供方法论内容"
                     }
                     
                 methodologies[problem_type] = content
@@ -113,7 +113,7 @@ class MethodologyTool:
                 action = "更新" if problem_type in methodologies else "添加"
                 return {
                     "success": True,
-                    "stdout": f"已{action}问题类型 '{problem_type}' 的经验总结"
+                    "stdout": f"已{action}问题类型 '{problem_type}' 的方法论"
                 }
                 
             else:
@@ -129,13 +129,13 @@ class MethodologyTool:
             }
             
     def get_methodology(self, problem_type: str) -> Optional[str]:
-        """获取指定问题类型的经验总结
+        """获取指定问题类型的方法论
         
         Args:
             problem_type: 问题类型
             
         Returns:
-            Optional[str]: 经验总结内容，如果不存在则返回 None
+            Optional[str]: 方法论内容，如果不存在则返回 None
         """
         methodologies = self._load_methodologies()
         return methodologies.get(problem_type) 

jarvis/tools/registry.py

@@ -99,7 +99,7 @@ class ToolRegistry:
                         parameters=tool_instance.parameters,
                         func=tool_instance.execute
                     )
-                    PrettyOutput.print(f"从 {file_path} 加载工具: {tool_instance.name}: {tool_instance.description}", OutputType.INFO)
+                    PrettyOutput.print(f"从 {file_path} 加载工具: {tool_instance.name}: {tool_instance.description}", OutputType.SUCCESS)
                     tool_found = True
                     break
                     

jarvis/tools/search.py

@@ -2,7 +2,39 @@ from typing import Dict, Any, List
 from jarvis.models.registry import PlatformRegistry
 from jarvis.utils import PrettyOutput, OutputType
 from jarvis.tools.webpage import WebpageTool
-from jarvis.tools.bing_search import bing_search
+from playwright.sync_api import sync_playwright
+from urllib.parse import quote
+
+def bing_search(query):
+    try:
+        with sync_playwright() as p:
+            browser = p.chromium.launch()
+            page = browser.new_page()
+            page.goto(
+                f"https://www.bing.com/search?form=QBRE&q={quote(query)}&cc=US"
+            )
+
+            page.wait_for_selector("#b_results", timeout=10000)
+            
+            summaries = page.evaluate("""() => {
+                const liElements = Array.from(
+                    document.querySelectorAll("#b_results > .b_algo")
+                );
+                return liElements.map((li) => {
+                    const abstractElement = li.querySelector(".b_caption > p");
+                    const linkElement = li.querySelector("a");
+                    const href = linkElement.getAttribute("href");
+                    const title = linkElement.textContent;
+                    const abstract = abstractElement ? abstractElement.textContent : "";
+                    return { href, title, abstract };
+                });
+            }""")
+            
+            browser.close()
+            print(summaries)
+            return summaries
+    except Exception as error:
+        print("An error occurred:", error)
 
 class SearchTool:
     name = "search"

jarvis/utils.py

@@ -158,7 +158,7 @@ def get_multiline_input(tip: str) -> str:
             lines.append(line)
             
     except KeyboardInterrupt:
-        PrettyOutput.print("\n输入已取消", OutputType.ERROR)
+        PrettyOutput.print("\n输入已取消", OutputType.INFO)
         return "__interrupt__"
     
     return "\n".join(lines)
@@ -200,3 +200,10 @@ def while_true(func, sleep_time: float = 0.1):
         PrettyOutput.print(f"执行失败，{sleep_time}s后重试...", OutputType.WARNING)
         time.sleep(sleep_time)
     return ret
+
+def find_git_root(dir="."):
+    curr_dir = os.getcwd()
+    os.chdir(dir)
+    ret = os.popen("git rev-parse --show-toplevel").read().strip()
+    os.chdir(curr_dir)
+    return ret