jarvis-ai-assistant 0.7.8__py3-none-any.whl → 1.0.2__py3-none-any.whl

jarvis/jarvis_utils/dialogue_recorder.py

@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+对话记录器模块
+
+提供对话记录和管理功能，支持多会话、JSONL格式存储、自动清理等功能。
+"""
+
+import atexit
+import json
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Optional
+
+from .config import get_data_dir
+
+# 全局实例变量
+_global_recorder: Optional["DialogueRecorder"] = None
+
+
+class DialogueRecorder:
+    """对话记录器类
+
+    用于记录和管理对话历史，支持多会话、JSONL格式存储。
+
+    特性：
+    - 自动生成会话ID
+    - JSONL格式存储，每行一个消息记录
+    - 支持元数据扩展
+    - 自动清理旧会话
+    - 进程安全的文件写入
+    """
+
+    def __init__(self, session_id: Optional[str] = None):
+        """初始化对话记录器
+
+        Args:
+            session_id: 会话ID，如果为None则使用当前会话ID
+        """
+        self.data_dir = Path(get_data_dir()) / "dialogues"
+        self._session_id_cache: Optional[str] = None
+        self.session_id = session_id or self._get_current_session_id()
+        self._ensure_data_dir()
+        self._register_cleanup_hook()
+
+    def __del__(self):
+        """析构函数，确保清理资源"""
+        if hasattr(self, "_cleanup_registered"):
+            self._unregister_cleanup_hook()
+
+    def start_recording(self) -> str:
+        """开始新的对话记录
+
+        Returns:
+            str: 新生成的会话ID
+        """
+        new_session_id = str(uuid.uuid4())
+        return new_session_id
+
+    def record_message(
+        self, role: str, content: str, metadata: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """记录消息
+
+        Args:
+            role: 消息角色（如'user', 'assistant', 'system'）
+            content: 消息内容
+            metadata: 可选的元数据
+        """
+        record = {
+            "timestamp": datetime.now().isoformat(),
+            "role": role,
+            "content": content,
+            "metadata": metadata or {},
+        }
+        self._write_record(record)
+
+    def get_session_file_path(self) -> str:
+        """获取当前会话文件路径
+
+        Returns:
+            str: 当前会话文件完整路径
+        """
+        return str(self._get_session_path(self.session_id))
+
+    def get_all_sessions(self) -> List[str]:
+        """获取所有会话ID列表
+
+        Returns:
+            List[str]: 所有会话ID列表
+        """
+        if not self.data_dir.exists():
+            return []
+
+        session_files = self.data_dir.glob("*.jsonl")
+        sessions = []
+        for file_path in session_files:
+            session_id = file_path.stem
+            if file_path.is_file() and session_id:
+                sessions.append(session_id)
+
+        return sorted(sessions)
+
+    def read_session(self, session_id: str) -> List[Dict[str, Any]]:
+        """读取指定会话内容
+
+        Args:
+            session_id: 会话ID
+
+        Returns:
+            List[Dict[str, Any]]: 会话消息列表
+        """
+        file_path = self._get_session_path(session_id)
+        if not file_path.exists():
+            return []
+
+        messages = []
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if line:
+                        try:
+                            message = json.loads(line)
+                            messages.append(message)
+                        except json.JSONDecodeError:
+                            continue
+        except Exception:
+            pass
+        return messages
+
+    def cleanup_session(self, session_id: Optional[str] = None) -> None:
+        """清理指定会话文件
+
+        Args:
+            session_id: 会话ID，如果为None则清理当前会话
+        """
+        session_to_cleanup = session_id or self.session_id
+        file_path = self._get_session_path(session_to_cleanup)
+
+        if file_path.exists():
+            try:
+                file_path.unlink()
+            except Exception:
+                pass
+
+    def cleanup_all_sessions(self) -> None:
+        """清理所有会话文件"""
+        if not self.data_dir.exists():
+            return
+
+        session_files = list(self.data_dir.glob("*.jsonl"))
+        if not session_files:
+            return
+
+        for file_path in session_files:
+            try:
+                file_path.unlink()
+            except Exception:
+                pass
+
+    def get_session_count(self) -> int:
+        """获取总会话数量
+
+        Returns:
+            int: 总会话数量
+        """
+        return len(self.get_all_sessions())
+
+    def _ensure_data_dir(self) -> None:
+        """确保数据目录存在"""
+        try:
+            self.data_dir.mkdir(parents=True, exist_ok=True)
+        except Exception:
+            pass
+
+    def _get_current_session_id(self) -> str:
+        """获取当前会话ID"""
+        # 从环境变量或配置中获取当前会话ID
+        # 如果没有则生成一个新的
+        if self._session_id_cache is not None:
+            return self._session_id_cache
+
+        # 检查是否有现有的会话文件
+        existing_sessions = self.get_all_sessions()
+        if existing_sessions:
+            # 使用最新的会话
+            session_id = existing_sessions[-1]
+            self._session_id_cache = session_id
+            return session_id
+
+        # 生成新的会话ID
+        new_session_id = str(uuid.uuid4())
+        self._session_id_cache = new_session_id
+        return new_session_id
+
+    def _write_record(self, record: Dict[str, Any]) -> None:
+        """写入单条记录到文件"""
+        file_path = self._get_session_path(self.session_id)
+
+        try:
+            with open(file_path, "a", encoding="utf-8") as f:
+                json.dump(record, f, ensure_ascii=False)
+                f.write("\n")
+        except Exception:
+            pass
+
+    def _get_session_path(self, session_id: str) -> Path:
+        """获取会话文件路径"""
+        return self.data_dir / f"{session_id}.jsonl"
+
+    def _register_cleanup_hook(self) -> None:
+        """注册atexit清理钩子"""
+        if not hasattr(self, "_cleanup_registered"):
+            atexit.register(self._cleanup_on_exit)
+            self._cleanup_registered = True
+
+    def _unregister_cleanup_hook(self) -> None:
+        """注销atexit清理钩子"""
+        if hasattr(self, "_cleanup_registered"):
+            try:
+                atexit.unregister(self._cleanup_on_exit)
+            except ValueError:
+                # 钩子可能已被注销或从未注册
+                pass
+            del self._cleanup_registered
+
+    def _cleanup_on_exit(self) -> None:
+        """进程退出时的清理函数
+
+        确保在进程正常和异常退出时清理当前会话文件
+        """
+        try:
+            # 只清理当前会话，避免影响其他会话
+            self.cleanup_session()
+        except Exception:
+            # 清理失败时不抛出异常，避免影响进程退出
+            pass
+
+
+def get_global_recorder() -> DialogueRecorder:
+    """获取全局单例对话记录器
+
+    Returns:
+        DialogueRecorder: 全局对话记录器实例
+    """
+    global _global_recorder
+    if _global_recorder is None:
+        _global_recorder = DialogueRecorder()
+    return _global_recorder
+
+
+def record_user_message(
+    content: str, metadata: Optional[Dict[str, Any]] = None
+) -> None:
+    """便捷函数：记录用户消息
+
+    Args:
+        content: 消息内容
+        metadata: 可选元数据
+    """
+    recorder = get_global_recorder()
+    recorder.record_message("user", content, metadata)
+
+
+def record_assistant_message(
+    content: str, metadata: Optional[Dict[str, Any]] = None
+) -> None:
+    """便捷函数：记录助手消息
+
+    Args:
+        content: 消息内容
+        metadata: 可选元数据
+    """
+    recorder = get_global_recorder()
+    recorder.record_message("assistant", content, metadata)
+
+
+def get_current_session_path() -> str:
+    """便捷函数：获取当前会话文件路径
+
+    Returns:
+        str: 当前会话文件路径
+    """
+    recorder = get_global_recorder()
+    return recorder.get_session_file_path()
+
+
+# 在模块导入时自动初始化和注册清理钩子
+_global_recorder = get_global_recorder()

jarvis/jarvis_utils/embedding.py

@@ -3,6 +3,7 @@ import os
 from pathlib import Path
 from typing import List
 
+from jarvis.jarvis_utils.output import PrettyOutput
 
 # 设置tiktoken缓存目录
 script_dir = Path(__file__).parent
@@ -30,8 +31,10 @@ def get_context_token_count(text: str) -> int:
         # 调整token计算为原来的10/7倍
         return int(len(encoding.encode(text)) * 10 / 7)
     except Exception as e:
-        print(f"⚠️ 计算token失败: {str(e)}")
-        return int(len(text) // 4 * 10 / 7)  # 每个token大约4个字符的粗略估计，调整为10/7倍
+        PrettyOutput.auto_print(f"⚠️ 计算token失败: {str(e)}")
+        return int(
+            len(text) // 4 * 10 / 7
+        )  # 每个token大约4个字符的粗略估计，调整为10/7倍
 
 
 def split_text_into_chunks(
@@ -80,6 +83,6 @@ def split_text_into_chunks(
         return chunks
 
     except Exception as e:
-        print(f"⚠️ 文本分割失败: {str(e)}")
+        PrettyOutput.auto_print(f"⚠️ 文本分割失败: {str(e)}")
         # 发生错误时回退到简单的字符分割
         return [text[i : i + max_length] for i in range(0, len(text), max_length)]

jarvis/jarvis_utils/file_processors.py

@@ -75,7 +75,13 @@ class TextFileProcessor(FileProcessor):
                     continue
 
             if not detected_encoding:
-                raise UnicodeDecodeError(f"Failed to decode file with supported encodings: {file_path}")  # type: ignore
+                raise UnicodeDecodeError(
+                    "utf-8",
+                    b"",
+                    0,
+                    0,
+                    f"Failed to decode file with supported encodings: {file_path}",
+                )
 
             # Use the detected encoding to read the file
             with open(file_path, "r", encoding=detected_encoding, errors="ignore") as f:

jarvis/jarvis_utils/fzf.py

@@ -1,8 +1,15 @@
 # -*- coding: utf-8 -*-
 """FZF选择器工具。"""
+
 import shutil
 import subprocess
-from typing import List, Optional, Union, Dict, Any, cast
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Union
+from typing import cast
+
 
 def fzf_select(
     options: Union[List[str], List[Dict[str, Any]]],
@@ -29,8 +36,7 @@ def fzf_select(
     if isinstance(options[0], dict):
         if key is None:
             raise ValueError("A key must be provided for a list of dicts.")
-        options_dict = cast(List[Dict[str, Any]], options)
-        input_lines = [str(item.get(key, "")) for item in options_dict]
+        input_lines = [str(cast(Dict[str, Any], item).get(key, "")) for item in options]
     else:
         input_lines = [str(item) for item in options]
 

jarvis/jarvis_utils/git_utils.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """
 Git工具模块
 该模块提供了与Git仓库交互的工具。
@@ -9,14 +8,25 @@ Git工具模块
 - 获取最新提交的哈希值
 - 从Git差异中提取修改的行范围
 """
+
 import datetime
 import os
+
+from jarvis.jarvis_utils.output import PrettyOutput
+
+# -*- coding: utf-8 -*-
 import re
 import subprocess
 import sys
-from typing import Any, Dict, List, Optional, Set, Tuple
-
-from jarvis.jarvis_utils.config import get_data_dir, is_confirm_before_apply_patch
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Set
+from typing import Tuple
+
+from jarvis.jarvis_utils.config import get_data_dir
+from jarvis.jarvis_utils.config import is_confirm_before_apply_patch
 from jarvis.jarvis_utils.input import user_confirm
 from jarvis.jarvis_utils.utils import is_rag_installed
 
@@ -110,7 +120,7 @@ def get_commits_between(start_hash: str, end_hash: str) -> List[Tuple[str, str]]
         )
         if result.returncode != 0:
             error_msg = result.stderr.decode("utf-8", errors="replace")
-            print(f"❌ 获取commit历史失败: {error_msg}")
+            PrettyOutput.auto_print(f"❌ 获取commit历史失败: {error_msg}")
             return []
 
         output = result.stdout.decode("utf-8", errors="replace")
@@ -122,7 +132,7 @@ def get_commits_between(start_hash: str, end_hash: str) -> List[Tuple[str, str]]
         return commits
 
     except Exception as e:
-        print(f"❌ 获取commit历史异常: {str(e)}")
+        PrettyOutput.auto_print(f"❌ 获取commit历史异常: {str(e)}")
         return []
 
 
@@ -185,7 +195,7 @@ def get_diff_between_commits(start_hash: str, end_hash: Optional[str] = None) ->
         if end_hash is None:
             # 如果end_hash为None，使用HEAD
             end_hash = "HEAD"
-        
+
         # 检查start_hash是否存在
         start_check = subprocess.run(
             ["git", "rev-parse", "--verify", start_hash],
@@ -194,7 +204,7 @@ def get_diff_between_commits(start_hash: str, end_hash: Optional[str] = None) ->
         )
         if start_check.returncode != 0:
             return f"起始commit不存在: {start_hash}"
-        
+
         # 检查end_hash是否存在
         end_check = subprocess.run(
             ["git", "rev-parse", "--verify", end_hash],
@@ -203,7 +213,7 @@ def get_diff_between_commits(start_hash: str, end_hash: Optional[str] = None) ->
         )
         if end_check.returncode != 0:
             return f"结束commit不存在: {end_hash}"
-        
+
         # 获取两个commit之间的差异
         result = subprocess.run(
             ["git", "diff", f"{start_hash}..{end_hash}"],
@@ -211,7 +221,7 @@ def get_diff_between_commits(start_hash: str, end_hash: Optional[str] = None) ->
             text=False,
             check=True,
         )
-        
+
         try:
             return result.stdout.decode("utf-8")
         except UnicodeDecodeError:
@@ -243,7 +253,7 @@ def revert_file(filepath: str) -> None:
         subprocess.run(["git", "clean", "-f", "--", filepath], check=True)
     except subprocess.CalledProcessError as e:
         error_msg = e.stderr.decode("utf-8", errors="replace") if e.stderr else str(e)
-        print(f"❌ 恢复文件失败: {error_msg}")
+        PrettyOutput.auto_print(f"❌ 恢复文件失败: {error_msg}")
 
 
 # 修改后的恢复函数
@@ -264,15 +274,15 @@ def revert_change() -> None:
             subprocess.run(["git", "reset", "--hard", "HEAD"], check=True)
         subprocess.run(["git", "clean", "-fd"], check=True)
     except subprocess.CalledProcessError as e:
-        print(f"❌ 恢复更改失败: {str(e)}")
+        PrettyOutput.auto_print(f"❌ 恢复更改失败: {str(e)}")
 
 
 def detect_large_code_deletion(threshold: int = 30) -> Optional[Dict[str, int]]:
     """检测是否有大量代码删除
-    
+
     参数:
         threshold: 净删除行数阈值，默认200行
-        
+
     返回:
         Optional[Dict[str, int]]: 如果检测到大量删除，返回包含统计信息的字典：
             {
@@ -284,15 +294,20 @@ def detect_large_code_deletion(threshold: int = 30) -> Optional[Dict[str, int]]:
     """
     try:
         # 临时暂存所有文件以便获取完整的diff统计
-        subprocess.run(["git", "add", "-N", "."], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-        
+        subprocess.run(
+            ["git", "add", "-N", "."],
+            check=False,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
         # 检查是否有HEAD
         head_check = subprocess.run(
             ["git", "rev-parse", "--verify", "HEAD"],
             stderr=subprocess.DEVNULL,
             stdout=subprocess.DEVNULL,
         )
-        
+
         if head_check.returncode == 0:
             # 有HEAD，获取相对于HEAD的diff统计
             diff_result = subprocess.run(
@@ -313,28 +328,35 @@ def detect_large_code_deletion(threshold: int = 30) -> Optional[Dict[str, int]]:
                 errors="replace",
                 check=False,
             )
-        
+
         # 重置暂存区
-        subprocess.run(["git", "reset"], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-        
+        subprocess.run(
+            ["git", "reset"],
+            check=False,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
         # 解析插入和删除行数
         if diff_result.returncode == 0 and diff_result.stdout:
             insertions = 0
             deletions = 0
-            insertions_match = re.search(r"(\d+)\s+insertions?\(\+\)", diff_result.stdout)
+            insertions_match = re.search(
+                r"(\d+)\s+insertions?\(\+\)", diff_result.stdout
+            )
             deletions_match = re.search(r"(\d+)\s+deletions?\(\-\)", diff_result.stdout)
             if insertions_match:
                 insertions = int(insertions_match.group(1))
             if deletions_match:
                 deletions = int(deletions_match.group(1))
-            
+
             # 检查是否有大量代码删除（净删除超过阈值）
             net_deletions = deletions - insertions
             if net_deletions > threshold:
                 return {
-                    'insertions': insertions,
-                    'deletions': deletions,
-                    'net_deletions': net_deletions
+                    "insertions": insertions,
+                    "deletions": deletions,
+                    "net_deletions": net_deletions,
                 }
         return None
     except Exception:
@@ -347,16 +369,16 @@ def detect_large_code_deletion(threshold: int = 30) -> Optional[Dict[str, int]]:
 
 def check_large_code_deletion(threshold: int = 30) -> bool:
     """检查是否有大量代码删除
-    
+
     参数:
         threshold: 净删除行数阈值，默认200行
-        
+
     返回:
         bool: 始终返回True，由调用方统一处理大模型询问
     """
     # 检测功能现在由调用方统一处理
     return True
-    
+
     # 直接返回True，让调用方统一处理大模型询问
     return True
 
@@ -556,17 +578,21 @@ def check_and_update_git_repo(repo_path: str) -> bool:
             and remote_tag_result.returncode == 0
             and local_tag_result.stdout.strip() != remote_tag_result.stdout.strip()
         ):
-            print(f"ℹ️ 检测到新版本tag {remote_tag_result.stdout.strip()}，正在更新Jarvis...")
+            PrettyOutput.auto_print(
+                f"ℹ️ 检测到新版本tag {remote_tag_result.stdout.strip()}，正在更新Jarvis..."
+            )
             subprocess.run(
                 ["git", "checkout", remote_tag_result.stdout.strip()],
                 cwd=git_root,
                 check=True,
             )
-            print(f"✅ Jarvis已更新到tag {remote_tag_result.stdout.strip()}")
+            PrettyOutput.auto_print(
+                f"✅ Jarvis已更新到tag {remote_tag_result.stdout.strip()}"
+            )
 
             # 执行pip安装更新代码
             try:
-                print("ℹ️ 正在安装更新后的代码...")
+                PrettyOutput.auto_print("ℹ️ 正在安装更新后的代码...")
 
                 # 检查是否在虚拟环境中
                 in_venv = hasattr(sys, "real_prefix") or (
@@ -575,6 +601,7 @@ def check_and_update_git_repo(repo_path: str) -> bool:
 
                 # 检测 uv 可用性：优先虚拟环境内的 uv，其次 PATH 中的 uv
                 from shutil import which as _which
+
                 uv_executable = None
                 if sys.platform == "win32":
                     venv_uv = os.path.join(sys.prefix, "Scripts", "uv.exe")
@@ -623,7 +650,7 @@ def check_and_update_git_repo(repo_path: str) -> bool:
                 )
 
                 if result.returncode == 0:
-                    print("✅ 代码更新安装成功")
+                    PrettyOutput.auto_print("✅ 代码更新安装成功")
                     return True
 
                 # 处理权限错误
@@ -641,21 +668,21 @@ def check_and_update_git_repo(repo_path: str) -> bool:
                             text=True,
                         )
                         if user_result.returncode == 0:
-                            print("✅ 用户级代码安装成功")
+                            PrettyOutput.auto_print("✅ 用户级代码安装成功")
                             return True
                         error_msg = user_result.stderr.strip()
 
-                print(f"❌ 代码安装失败: {error_msg}")
+                PrettyOutput.auto_print(f"❌ 代码安装失败: {error_msg}")
                 return False
             except Exception as e:
-                print(f"❌ 安装过程中发生意外错误: {str(e)}")
+                PrettyOutput.auto_print(f"❌ 安装过程中发生意外错误: {str(e)}")
                 return False
         # 更新检查日期文件
         with open(last_check_file, "w") as f:
             f.write(today_str)
         return False
     except Exception as e:
-        print(f"⚠️ Git仓库更新检查失败: {e}")
+        PrettyOutput.auto_print(f"⚠️ Git仓库更新检查失败: {e}")
         return False
     finally:
         os.chdir(curr_dir)
@@ -682,16 +709,16 @@ def get_diff_file_list() -> List[str]:
         subprocess.run(["git", "reset"], check=True)
 
         if result.returncode != 0:
-            print(f"❌ 获取差异文件列表失败: {result.stderr}")
+            PrettyOutput.auto_print(f"❌ 获取差异文件列表失败: {result.stderr}")
             return []
 
         return [f for f in result.stdout.splitlines() if f]
 
     except subprocess.CalledProcessError as e:
-        print(f"❌ 获取差异文件列表失败: {str(e)}")
+        PrettyOutput.auto_print(f"❌ 获取差异文件列表失败: {str(e)}")
         return []
     except Exception as e:
-        print(f"❌ 获取差异文件列表异常: {str(e)}")
+        PrettyOutput.auto_print(f"❌ 获取差异文件列表异常: {str(e)}")
         return []
 
 
@@ -841,7 +868,7 @@ def confirm_add_new_files() -> None:
 
         if output_lines:
             emoji = "⚠️ " if need_confirm else "ℹ️ "
-            print(emoji + ("\n" + emoji).join(output_lines))
+            PrettyOutput.auto_print(emoji + ("\n" + emoji).join(output_lines))
 
         return need_confirm
 
@@ -892,9 +919,11 @@ def confirm_add_new_files() -> None:
                         entry = rel_path if not rel_path.startswith("..") else file
                         if entry not in existing_lines:
                             f.write(entry + "\n")
-                print("ℹ️ 已将未跟踪文件添加到 .gitignore，正在重新检测...")
+                PrettyOutput.auto_print(
+                    "ℹ️ 已将未跟踪文件添加到 .gitignore，正在重新检测..."
+                )
             except Exception as e:
-                print(f"⚠️ 更新 .gitignore 失败: {str(e)}")
+                PrettyOutput.auto_print(f"⚠️ 更新 .gitignore 失败: {str(e)}")
 
             continue