jarvis-ai-assistant 0.1.220__py3-none-any.whl → 0.1.222__py3-none-any.whl

jarvis/jarvis_agent/session_manager.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+import os
+from typing import Any, Dict, Optional, TYPE_CHECKING
+
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+
+if TYPE_CHECKING:
+    from jarvis.jarvis_platform.base import BasePlatform
+
+
+class SessionManager:
+    """
+    Manages the session state of an agent, including conversation history,
+    user data, and persistence.
+    """
+
+    def __init__(self, model: "BasePlatform", agent_name: str):
+        self.model = model
+        self.agent_name = agent_name
+        self.prompt: str = ""
+        self.conversation_length: int = 0
+        self.user_data: Dict[str, Any] = {}
+        self.addon_prompt: str = ""
+
+    def set_user_data(self, key: str, value: Any):
+        """Sets a value in the user data dictionary."""
+        self.user_data[key] = value
+
+    def get_user_data(self, key: str) -> Optional[Any]:
+        """Gets a value from the user data dictionary."""
+        return self.user_data.get(key)
+
+    def set_addon_prompt(self, addon_prompt: str):
+        """Sets the addon prompt for the next model call."""
+        self.addon_prompt = addon_prompt
+
+    def clear(self):
+        """
+        Clears the current conversation history, prompt, and length counter.
+        """
+        self.model.reset()
+        self.conversation_length = 0
+        self.prompt = ""
+
+    def save_session(self) -> bool:
+        """Saves the current session state to a file."""
+        session_dir = os.path.join(os.getcwd(), ".jarvis")
+        os.makedirs(session_dir, exist_ok=True)
+        platform_name = self.model.platform_name()
+        model_name = self.model.name().replace("/", "_").replace("\\", "_")
+        session_file = os.path.join(
+            session_dir,
+            f"saved_session_{self.agent_name}_{platform_name}_{model_name}.json",
+        )
+        return self.model.save(session_file)
+
+    def restore_session(self) -> bool:
+        """Restores the session state from a file."""
+        platform_name = self.model.platform_name()
+        model_name = self.model.name().replace("/", "_").replace("\\", "_")
+        session_file = os.path.join(
+            os.getcwd(),
+            ".jarvis",
+            f"saved_session_{self.agent_name}_{platform_name}_{model_name}.json",
+        )
+        if not os.path.exists(session_file):
+            return False
+
+        if self.model.restore(session_file):
+            try:
+                os.remove(session_file)
+                PrettyOutput.print("会话已恢复，并已删除会话文件。", OutputType.SUCCESS)
+            except OSError as e:
+                PrettyOutput.print(f"删除会话文件失败: {e}", OutputType.ERROR)
+            return True
+        return False
+
+    def clear_history(self):
+        """
+        Clears conversation history but keeps the system prompt by resetting the model state.
+        """
+        self.prompt = ""
+        self.model.reset()
+        self.conversation_length = 0

jarvis/jarvis_agent/tool_executor.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+from typing import Any, Tuple, TYPE_CHECKING
+
+from jarvis.jarvis_utils.input import user_confirm
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+
+if TYPE_CHECKING:
+    from jarvis.jarvis_agent import Agent
+
+
+def execute_tool_call(response: str, agent: "Agent") -> Tuple[bool, Any]:
+    """
+    Parses the model's response, identifies the appropriate tool, and executes it.
+
+    Args:
+        response: The response string from the model, potentially containing a tool call.
+        agent: The agent instance, providing context like output handlers and settings.
+
+    Returns:
+        A tuple containing:
+        - A boolean indicating if the tool's result should be returned to the user.
+        - The result of the tool execution or an error message.
+    """
+    tool_list = []
+    for handler in agent.output_handler:
+        if handler.can_handle(response):
+            tool_list.append(handler)
+
+    if len(tool_list) > 1:
+        error_message = (
+            f"操作失败：检测到多个操作。一次只能执行一个操作。"
+            f"尝试执行的操作：{', '.join([handler.name() for handler in tool_list])}"
+        )
+        PrettyOutput.print(error_message, OutputType.WARNING)
+        return False, error_message
+
+    if not tool_list:
+        return False, ""
+
+    tool_to_execute = tool_list[0]
+    if not agent.execute_tool_confirm or user_confirm(
+        f"需要执行{tool_to_execute.name()}确认执行？", True
+    ):
+        print(f"🔧 正在执行{tool_to_execute.name()}...")
+        result = tool_to_execute.handle(response, agent)
+        print(f"✅ {tool_to_execute.name()}执行完成")
+        return result
+
+    return False, ""

jarvis/jarvis_code_agent/code_agent.py

@@ -18,7 +18,7 @@ from jarvis.jarvis_code_agent.lint import get_lint_tools
 from jarvis.jarvis_git_utils.git_commiter import GitCommitTool
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_tools.registry import ToolRegistry
-from jarvis.jarvis_utils.config import is_confirm_before_apply_patch
+from jarvis.jarvis_utils.config import is_confirm_before_apply_patch, is_enable_static_analysis
 from jarvis.jarvis_utils.git_utils import (
     confirm_add_new_files,
     find_git_root_and_cd,
@@ -43,8 +43,7 @@ class CodeAgent:
 
     def __init__(
         self,
-        platform: Optional[str] = None,
-        model: Optional[str] = None,
+        llm_type: str = "normal",
         need_summary: bool = True,
     ):
         self.root_dir = os.getcwd()
@@ -113,21 +112,12 @@ class CodeAgent:
 10. 我不订阅闲 AI
 </say_to_llm>
 """
-        # 处理platform参数
-        platform_instance = (
-            PlatformRegistry().create_platform(platform)  # type: ignore
-            if platform
-            else PlatformRegistry().get_normal_platform()
-        )  # type: ignore
-        if model:
-            platform_instance.set_model_name(model)  # type: ignore
-
         self.agent = Agent(
             system_prompt=code_system_prompt,
             name="CodeAgent",
             auto_complete=False,
             output_handler=[tool_registry, EditFileHandler()],
-            platform=platform_instance,
+            llm_type=llm_type,
             input_handler=[shell_input_handler, builtin_input_handler],
             need_summary=need_summary,
             use_methodology=False,  # 禁用方法论
@@ -374,7 +364,7 @@ class CodeAgent:
                         if lint_tools_info
                         else ""
                     )
-                    if lint_tools_info:
+                    if lint_tools_info and is_enable_static_analysis():
                         addon_prompt = f"""
 请对以下修改的文件进行静态扫描:
 {file_list}
@@ -392,19 +382,19 @@ class CodeAgent:
             return
         # 用户确认最终结果
         if commited:
-            agent.prompt += final_ret
+            agent.session.prompt += final_ret
             return
         PrettyOutput.print(final_ret, OutputType.USER, lang="markdown")
         if not is_confirm_before_apply_patch() or user_confirm(
             "是否使用此回复？", default=True
         ):
-            agent.prompt += final_ret
+            agent.session.prompt += final_ret
             return
-        agent.prompt += final_ret
+        agent.session.prompt += final_ret
         custom_reply = get_multiline_input("请输入自定义回复")
         if custom_reply.strip():  # 如果自定义回复为空，返回空字符串
             agent.set_addon_prompt(custom_reply)
-        agent.prompt += final_ret
+        agent.session.prompt += final_ret
 
 
 def main() -> None:
@@ -413,10 +403,11 @@ def main() -> None:
 
     parser = argparse.ArgumentParser(description="Jarvis Code Agent")
     parser.add_argument(
-        "-p", "--platform", type=str, help="Target platform name", default=None
-    )
-    parser.add_argument(
-        "-m", "--model", type=str, help="Model name to use", default=None
+        "--llm_type",
+        type=str,
+        default="normal",
+        choices=["normal", "thinking"],
+        help="LLM type to use",
     )
     parser.add_argument(
         "-r", "--requirement", type=str, help="Requirement to process", default=None
@@ -434,7 +425,7 @@ def main() -> None:
     PrettyOutput.print(f"当前目录: {git_dir}", OutputType.INFO)
 
     try:
-        agent = CodeAgent(platform=args.platform, model=args.model, need_summary=False)
+        agent = CodeAgent(llm_type=args.llm_type, need_summary=False)
 
         # 尝试恢复会话
         if args.restore_session:

jarvis/jarvis_code_analysis/code_review.py

@@ -638,7 +638,7 @@ class CodeReviewTool:
 [在此处插入完整MARKDOWN格式的审查报告]
 {ct("REPORT")}""",
                     output_handler=[tool_registry],
-                    platform=PlatformRegistry().get_thinking_platform(),
+                    llm_type="thinking",
                     auto_complete=False,
                 )
 

jarvis/jarvis_data/config_schema.json

@@ -181,34 +181,29 @@
       "description": "是否打印提示",
       "default": false
     },
+    "JARVIS_ENABLE_STATIC_ANALYSIS": {
+      "type": "boolean",
+      "description": "是否启用静态代码分析",
+      "default": true
+    },
     "JARVIS_RAG": {
       "type": "object",
       "description": "RAG框架的配置",
       "properties": {
-        "embedding_mode": {
-          "type": "string",
-          "enum": [
-            "performance",
-            "accuracy"
-          ],
-          "default": "performance",
-          "description": "嵌入模型的模式, 'performance'表示性能优先, 'accuracy'表示准确度优先"
-        },
-        "embedding_cache_path": {
+        "embedding_model": {
           "type": "string",
-          "default": ".jarvis/rag/embeddings",
-          "description": "嵌入向量缓存的路径, 相对于当前工作目录"
+          "default": "BAAI/bge-base-zh-v1.5",
+          "description": "用于RAG的嵌入模型的名称, 默认为 'BAAI/bge-base-zh-v1.5'"
         },
-        "vector_db_path": {
+        "rerank_model": {
           "type": "string",
-          "default": ".jarvis/rag/vectordb",
-          "description": "向量数据库的持久化存储路径, 相对于当前工作目录"
+          "default": "BAAI/bge-reranker-base",
+          "description": "用于RAG的rerank模型的名称, 默认为 'BAAI/bge-reranker-base'"
         }
       },
       "default": {
-        "embedding_mode": "performance",
-        "embedding_cache_path": ".jarvis/rag/embeddings",
-        "vector_db_path": ".jarvis/rag/vectordb"
+        "embedding_model": "BAAI/bge-base-zh-v1.5",
+        "rerank_model": "BAAI/bge-reranker-base"
       }
     },
     "JARVIS_REPLACE_MAP": {

jarvis/jarvis_git_details/main.py

@@ -199,7 +199,7 @@ class GitCommitAnalyzer:
 [检查代码是否符合行业最佳实践和项目规范]
 {ct("REPORT")}""",
             output_handler=[tool_registry],
-            platform=PlatformRegistry().get_normal_platform(),
+            llm_type="normal",
             auto_complete=True,
         )
 

jarvis/jarvis_platform/kimi.py

@@ -26,6 +26,7 @@ class KimiModel(BasePlatform):
         return [
             ("kimi", "基于网页的 Kimi，免费接口"),
             ("k1", "基于网页的 Kimi，深度思考模型"),
+            ("k2", "基于网页的 Kimi，深度思考模型 K2"),
         ]
 
     def __init__(self):
@@ -278,8 +279,9 @@ class KimiModel(BasePlatform):
             "use_search": True if self.web else False,
             "extend": {"sidebar": True},
             "kimiplus_id": "kimi",
-            "use_research": False,
-            "use_math": False,
+            "use_deep_research": False,
+            "use_semantic_memory": True,
+            "history": [],
             "refs": refs,
             "refs_file": refs_file,
             "model": self.model_name,

jarvis/jarvis_rag/__init__.py

@@ -1,7 +1,7 @@
 """
-Jarvis RAG Framework
+Jarvis RAG 框架
 
-A flexible RAG pipeline with pluggable remote LLMs and local, cache-enabled embedding models.
+一个灵活的RAG管道，具有可插拔的远程LLM和本地带缓存的嵌入模型。
 """
 
 from .rag_pipeline import JarvisRAGPipeline

jarvis/jarvis_rag/cache.py

@@ -6,74 +6,72 @@ from diskcache import Cache
 
 class EmbeddingCache:
     """
-    A disk-based cache for storing and retrieving text embeddings.
+    一个用于存储和检索文本嵌入的基于磁盘的缓存。
 
-    This class uses diskcache to create a persistent, local cache. It generates
-    a key for each text content based on its SHA256 hash, making lookups
-    deterministic and efficient.
+    该类使用diskcache创建一个持久化的本地缓存。它根据每个文本内容的
+    SHA256哈希值为其生成一个键，使得查找过程具有确定性和高效性。
     """
 
     def __init__(self, cache_dir: str, salt: str = ""):
         """
-        Initializes the EmbeddingCache.
+        初始化EmbeddingCache。
 
-        Args:
-            cache_dir (str): The directory where the cache will be stored.
-            salt (str): A salt to be added to the hash. This is crucial for
-                        ensuring that embeddings generated by different models
-                        do not collide. For example, use the model name as a salt.
+        参数:
+            cache_dir (str): 缓存将要存储的目录。
+            salt (str): 添加到哈希中的盐值。这对于确保由不同模型生成的
+                        嵌入不会发生冲突至关重要。例如，可以使用模型名称作为盐值。
         """
         self.cache = Cache(cache_dir)
         self.salt = salt
 
     def _get_key(self, text: str) -> str:
-        """Generates a unique cache key for a given text and salt."""
+        """为一个给定的文本和盐值生成一个唯一的缓存键。"""
         hash_object = hashlib.sha256((self.salt + text).encode("utf-8"))
         return hash_object.hexdigest()
 
     def get(self, text: str) -> Optional[Any]:
         """
-        Retrieves an embedding from the cache.
+        从缓存中检索一个嵌入。
 
-        Args:
-            text (str): The text to look up.
+        参数:
+            text (str): 要查找的文本。
 
-        Returns:
-            The cached embedding, or None if it's not in the cache.
+        返回:
+            缓存的嵌入，如果不在缓存中则返回None。
         """
         key = self._get_key(text)
         return self.cache.get(key)
 
     def set(self, text: str, embedding: Any) -> None:
         """
-        Stores an embedding in the cache.
+        在缓存中存储一个嵌入。
 
-        Args:
-            text (str): The text corresponding to the embedding.
-            embedding (Any): The embedding vector to store.
+        参数:
+            text (str): 与嵌入相对应的文本。
+            embedding (Any): 要存储的嵌入向量。
         """
         key = self._get_key(text)
         self.cache.set(key, embedding)
 
     def get_batch(self, texts: List[str]) -> List[Optional[Any]]:
         """
-        Retrieves a batch of embeddings from the cache.
+        从缓存中检索一批嵌入。
 
-        Args:
-            texts (List[str]): A list of texts to look up.
+        参数:
+            texts (List[str]): 要查找的文本列表。
 
-        Returns:
-            A list containing cached embeddings or None for cache misses.
+        返回:
+            一个列表，其中包含缓存的嵌入，对于缓存未命中的情况则为None。
         """
         return [self.get(text) for text in texts]
 
     def set_batch(self, texts: List[str], embeddings: List[Any]) -> None:
         """
-        Stores a batch of embeddings in the cache.
+        在缓存中存储一批嵌入。
 
-        Args:
-            texts (List[str]): The list of texts.
-            embeddings (List[Any]): The list of corresponding embeddings.
+        参数:
+            texts (List[str]): 文本列表。
+            embeddings (List[Any]): 相应的嵌入列表。
         """
         if len(texts) != len(embeddings):
             raise ValueError("Length of texts and embeddings must be the same.")
@@ -83,5 +81,5 @@ class EmbeddingCache:
                 self.set(text, embedding)
 
     def close(self):
-        """Closes the cache connection."""
+        """关闭缓存连接。"""
         self.cache.close()