jfox-cli 0.4.0__tar.gz → 0.4.1__tar.gz

{jfox_cli-0.4.0 → jfox_cli-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jfox-cli
-Version: 0.4.0
+Version: 0.4.1
 Summary: JFox - Zettelkasten 知识管理 CLI 工具
 Project-URL: Homepage, https://github.com/zhuxixi/jfox
 Project-URL: Repository, https://github.com/zhuxixi/jfox

{jfox_cli-0.4.0 → jfox_cli-0.4.1}/jfox/__init__.py

@@ -1,5 +1,5 @@
 """JFox - Zettelkasten 知识管理工具"""
 
-__version__ = "0.4.0"
+__version__ = "0.4.1"
 __author__ = "User"
 __email__ = "user@example.com"

{jfox_cli-0.4.0 → jfox_cli-0.4.1}/jfox/cli.py

@@ -2612,7 +2612,10 @@ def daemon(
 
     try:
         if action == "start":
+            from .daemon.process import DAEMON_LOG_FILE
+
             console.print("[yellow]正在启动 embedding daemon...[/yellow]")
+            console.print(f"[dim]日志文件: {DAEMON_LOG_FILE}[/dim]")
             ok = start_daemon(port=port)
             if ok:
                 info = get_daemon_status()
@@ -2631,6 +2634,7 @@ def daemon(
                     console.print("[green]✓ Daemon 已启动[/green]")
             else:
                 console.print("[red]✗ Daemon 启动失败[/red]")
+                console.print(f"[dim]查看日志: {DAEMON_LOG_FILE}[/dim]")
                 raise typer.Exit(1)
 
         elif action == "stop":

{jfox_cli-0.4.0 → jfox_cli-0.4.1}/jfox/daemon/__init__.py

@@ -3,9 +3,16 @@
 DEFAULT_HOST = "127.0.0.1"
 DEFAULT_PORT = 18700
 
-from .process import get_daemon_status, is_daemon_running, start_daemon, stop_daemon
+from .process import (
+    DAEMON_LOG_FILE,
+    get_daemon_status,
+    is_daemon_running,
+    start_daemon,
+    stop_daemon,
+)
 
 __all__ = [
+    "DAEMON_LOG_FILE",
     "DEFAULT_HOST",
     "DEFAULT_PORT",
     "start_daemon",

{jfox_cli-0.4.0 → jfox_cli-0.4.1}/jfox/daemon/process.py

@@ -36,6 +36,8 @@ def _get_pythonw_executable() -> str:
 logger = logging.getLogger(__name__)
 
 STARTUP_TIMEOUT = 60  # 模型加载可能较慢
+FIRST_RUN_TIMEOUT = 300  # 首次下载模型超时（秒）
+DAEMON_LOG_FILE = Path.home() / ".jfox_daemon.log"
 PID_FILE = Path.home() / ".jfox_daemon.pid"
 
 
@@ -103,6 +105,56 @@ def is_daemon_running() -> bool:
     return False
 
 
+def _check_model_cache() -> dict:
+    """
+    检查当前模型是否已缓存
+
+    Returns:
+        dict: {"needs_download": bool, "model_name": str, "size_hint": str}
+    """
+    try:
+        from ..config import config as _cfg
+        from ..embedding_backend import _CPU_DEFAULT_MODEL, _GPU_DEFAULT_MODEL
+
+        # 确定目标模型名
+        model_name = _cfg.embedding_model
+        if model_name == "auto" or not model_name:
+            try:
+                import torch
+
+                if torch.cuda.is_available():
+                    model_name = _GPU_DEFAULT_MODEL
+                else:
+                    model_name = _CPU_DEFAULT_MODEL
+            except Exception:
+                model_name = _CPU_DEFAULT_MODEL
+
+        # 检查 HuggingFace 缓存
+        hf_home = os.environ.get("HF_HOME", str(Path.home() / ".cache" / "huggingface"))
+        hub_cache = os.environ.get("HUGGINGFACE_HUB_CACHE", str(Path(hf_home) / "hub"))
+        model_cache_dir = Path(hub_cache) / f"models--{model_name.replace('/', '--')}"
+
+        size_hint = "2GB" if "bge-m3" in model_name else "90MB"
+
+        if model_cache_dir.exists():
+            snapshots_dir = model_cache_dir / "snapshots"
+            has_files = snapshots_dir.exists() and any(snapshots_dir.iterdir())
+            return {
+                "needs_download": not has_files,
+                "model_name": model_name,
+                "size_hint": size_hint,
+            }
+
+        return {
+            "needs_download": True,
+            "model_name": model_name,
+            "size_hint": size_hint,
+        }
+    except Exception as e:
+        logger.debug(f"Model cache check failed, assuming download needed: {e}")
+        return {"needs_download": True, "model_name": "unknown", "size_hint": ""}
+
+
 def start_daemon(host: str = DEFAULT_HOST, port: int = DEFAULT_PORT) -> bool:
     """
     启动 daemon 后台进程
@@ -124,6 +176,15 @@ def start_daemon(host: str = DEFAULT_HOST, port: int = DEFAULT_PORT) -> bool:
         )
         return True
 
+    # 首次启动预检：检查模型缓存是否存在
+    timeout = STARTUP_TIMEOUT
+    cache_info = _check_model_cache()
+    if cache_info["needs_download"]:
+        logger.info(
+            f"首次启动需要下载模型 {cache_info['model_name']}" f"（约 {cache_info['size_hint']}）"
+        )
+        timeout = FIRST_RUN_TIMEOUT
+
     # 构建启动命令（Windows 使用 pythonw.exe 避免控制台窗口）
     cmd = [
         _get_pythonw_executable(),
@@ -137,7 +198,6 @@ def start_daemon(host: str = DEFAULT_HOST, port: int = DEFAULT_PORT) -> bool:
 
     kwargs = {}
     if sys.platform == "win32":
-        # Windows: 后台分离进程，不弹窗
         CREATE_NEW_PROCESS_GROUP = 0x00000200
         DETACHED_PROCESS = 0x00000008
         CREATE_NO_WINDOW = 0x08000000
@@ -145,39 +205,46 @@ def start_daemon(host: str = DEFAULT_HOST, port: int = DEFAULT_PORT) -> bool:
     else:
         kwargs["start_new_session"] = True
 
+    # 子进程日志落盘（stdout/stderr → 日志文件）
+    log_file = open(DAEMON_LOG_FILE, "a", encoding="utf-8")
+
     try:
         proc = subprocess.Popen(
             cmd,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
+            stdout=log_file,
+            stderr=log_file,
             stdin=subprocess.DEVNULL,
             **kwargs,
         )
         logger.info(f"Daemon 进程已启动 (PID: {proc.pid})")
+        logger.info(f"Daemon 日志文件: {DAEMON_LOG_FILE}")
     except Exception as e:
+        log_file.close()
         logger.error(f"启动 daemon 失败: {e}")
         return False
 
     # 等待 daemon 就绪（用 HTTP 健康检查判断，不用 PID）
-    for i in range(STARTUP_TIMEOUT):
-        time.sleep(1)
-        health = _http_health_check(host, port)
-        if health is not None:
-            # 从 daemon 自身获取真实 PID
-            real_pid = health.get("pid", proc.pid)
-            _write_pid_file(
-                {
-                    "pid": real_pid,
-                    "host": host,
-                    "port": port,
-                    "started_at": time.time(),
-                }
-            )
-            logger.info(f"Daemon 已就绪 (PID: {real_pid}, port: {port})")
-            return True
+    try:
+        for i in range(timeout):
+            time.sleep(1)
+            health = _http_health_check(host, port)
+            if health is not None:
+                real_pid = health.get("pid", proc.pid)
+                _write_pid_file(
+                    {
+                        "pid": real_pid,
+                        "host": host,
+                        "port": port,
+                        "started_at": time.time(),
+                    }
+                )
+                logger.info(f"Daemon 已就绪 (PID: {real_pid}, port: {port})")
+                return True
 
-    logger.warning("Daemon 启动超时")
-    return False
+        logger.warning(f"Daemon 启动超时（{timeout}秒），日志见 {DAEMON_LOG_FILE}")
+        return False
+    finally:
+        log_file.close()
 
 
 def stop_daemon() -> bool:

{jfox_cli-0.4.0 → jfox_cli-0.4.1}/jfox/indexer.py

@@ -249,8 +249,8 @@ class Indexer:
         if not notes_dir.exists():
             return 0
 
-        # 清除旧索引数据，确保干净重建
-        self.vector_store.clear()
+        # 彻底重建 collection（删除旧结构 + 重建，解决模型切换后维度不匹配）
+        self.vector_store.reset_collection()
 
         # Find all note files
         note_files = list(notes_dir.rglob("*.md"))

{jfox_cli-0.4.0 → jfox_cli-0.4.1}/jfox/vector_store.py

@@ -1,6 +1,7 @@
 """ChromaDB 向量存储封装"""
 
 import logging
+import re
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -82,7 +83,26 @@ class VectorStore:
             return True
 
         except Exception as e:
-            logger.error(f"Failed to add note {note.id}: {e}")
+            error_msg = str(e)
+            if "dimension" in error_msg.lower() and "expecting" in error_msg.lower():
+                # 维度不匹配：模型已切换，提示用户 rebuild
+                dim_match = re.search(r"dimension of (\d+).*got (\d+)", error_msg, re.IGNORECASE)
+                if dim_match:
+                    old_dim, new_dim = dim_match.group(1), dim_match.group(2)
+                    logger.error(
+                        f"Embedding 维度不匹配（collection: {old_dim}, "
+                        f"当前模型: {new_dim}）。"
+                        f"可能是模型已切换，请执行 jfox index rebuild "
+                        f"重建索引。原始错误: {error_msg}"
+                    )
+                else:
+                    logger.error(
+                        f"Embedding 维度不匹配，可能是模型已切换。"
+                        f"请执行 jfox index rebuild 重建索引。"
+                        f"原始错误: {error_msg}"
+                    )
+            else:
+                logger.error(f"Failed to add note {note.id}: {error_msg}")
             return False
 
     def search(
@@ -206,6 +226,37 @@ class VectorStore:
             logger.error(f"Failed to clear vector store: {e}")
             return False
 
+    def reset_collection(self) -> bool:
+        """
+        彻底删除并重建 collection（用于 index rebuild）
+
+        与 clear() 不同，reset_collection() 会删除整个 collection 结构再重建，
+        确保 embedding dimension 等元信息也被重置。
+        适用于切换模型后需要 rebuild 的场景。
+
+        Returns:
+            是否成功重建
+        """
+        if self.client is None:
+            self.init()
+
+        try:
+            self.client.delete_collection("notes")
+            logger.info("Deleted old collection 'notes'")
+        except ValueError:
+            # ChromaDB 对不存在的 collection 抛 ValueError，这是正常情况
+            logger.debug("Collection 'notes' did not exist, skipping delete")
+
+        try:
+            self.collection = self.client.get_or_create_collection(
+                name="notes", metadata={"hnsw:space": "cosine"}
+            )
+            logger.info("Recreated collection 'notes'")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to recreate collection: {e}")
+            return False
+
 
 # 全局向量存储实例
 _vector_store: Optional[VectorStore] = None

{jfox_cli-0.4.0 → jfox_cli-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "jfox-cli"
-version = "0.4.0"
+version = "0.4.1"
 description = "JFox - Zettelkasten 知识管理 CLI 工具"
 readme = "README.md"
 license = {text = "MIT"}

{jfox_cli-0.4.0 → jfox_cli-0.4.1}/tests/unit/test_daemon_process.py

@@ -1,6 +1,7 @@
 """Daemon 进程管理单元测试"""
 
 import sys
+from pathlib import Path
 from unittest.mock import patch
 
 import pytest
@@ -84,3 +85,77 @@ class TestStartDaemonWindowsExecutable:
         flags = kwargs.get("creationflags", 0)
         CREATE_NO_WINDOW = 0x08000000
         assert flags & CREATE_NO_WINDOW, "CREATE_NO_WINDOW flag not set"
+
+
+class TestDaemonLogFile:
+    """测试 daemon 子进程日志落盘"""
+
+    @patch("jfox.daemon.process.subprocess.Popen")
+    @patch("jfox.daemon.process._http_health_check")
+    def test_start_daemon_writes_to_log_file(self, mock_health, mock_popen):
+        """start_daemon 应将子进程 stdout/stderr 重定向到日志文件"""
+        import subprocess
+
+        from jfox.daemon.process import start_daemon
+
+        mock_health.side_effect = [None, {"pid": 9999}]
+        mock_popen.return_value.pid = 1234
+
+        start_daemon()
+
+        call_kwargs = mock_popen.call_args[1]
+        # stdout 和 stderr 不应是 DEVNULL
+        assert call_kwargs["stdout"] != subprocess.DEVNULL
+        assert call_kwargs["stderr"] != subprocess.DEVNULL
+
+    @patch("jfox.daemon.process.subprocess.Popen")
+    @patch("jfox.daemon.process._http_health_check")
+    def test_daemon_log_file_path(self, mock_health, mock_popen):
+        """DAEMON_LOG_FILE 应在用户 home 目录下"""
+        from jfox.daemon.process import DAEMON_LOG_FILE
+
+        assert str(DAEMON_LOG_FILE).endswith(".jfox_daemon.log")
+        assert DAEMON_LOG_FILE.parent == Path.home()
+
+
+class TestDaemonModelCacheCheck:
+    """测试模型缓存预检"""
+
+    def test_check_model_cache_returns_dict(self):
+        """_check_model_cache 应返回包含必要键的字典"""
+        from jfox.daemon.process import _check_model_cache
+
+        result = _check_model_cache()
+        assert "needs_download" in result
+        assert "model_name" in result
+        assert "size_hint" in result
+        assert isinstance(result["needs_download"], bool)
+
+    @patch("jfox.daemon.process.os.environ", {})
+    def test_first_run_timeout_is_longer(self):
+        """FIRST_RUN_TIMEOUT 应大于 STARTUP_TIMEOUT"""
+        from jfox.daemon.process import FIRST_RUN_TIMEOUT, STARTUP_TIMEOUT
+
+        assert FIRST_RUN_TIMEOUT > STARTUP_TIMEOUT
+        assert FIRST_RUN_TIMEOUT >= 300
+
+    @patch("jfox.daemon.process._check_model_cache")
+    @patch("jfox.daemon.process.subprocess.Popen")
+    @patch("jfox.daemon.process._http_health_check")
+    def test_first_run_uses_extended_timeout(self, mock_health, mock_popen, mock_cache):
+        """首次下载模型时应使用 FIRST_RUN_TIMEOUT"""
+        from jfox.daemon.process import start_daemon
+
+        mock_health.side_effect = [None, {"pid": 9999}]
+        mock_popen.return_value.pid = 1234
+        mock_cache.return_value = {
+            "needs_download": True,
+            "model_name": "BAAI/bge-m3",
+            "size_hint": "2GB",
+        }
+
+        start_daemon()
+
+        # 验证 health check 被调用了足够多次（使用 FIRST_RUN_TIMEOUT）
+        # 由于第二次就返回了，至少被调用了 2 次
+        assert mock_health.call_count >= 2

{jfox_cli-0.4.0 → jfox_cli-0.4.1}/tests/unit/test_indexer_clear_before_rebuild.py

@@ -1,7 +1,7 @@
 """
-测试 Indexer.index_all() 在重建前清除旧数据
+测试 Indexer.index_all() 在重建前重置 collection
 
-验证 rebuild 流程：先 clear 再 index
+验证 rebuild 流程：先 reset_collection 再 index
 """
 
 import tempfile
@@ -9,11 +9,11 @@ from pathlib import Path
 from unittest.mock import MagicMock, patch
 
 
-class TestIndexerClearBeforeRebuild:
-    """Indexer.index_all() 应先清除旧索引再重建"""
+class TestIndexerResetBeforeRebuild:
+    """Indexer.index_all() 应先重置 collection 再重建"""
 
-    def test_index_all_calls_vector_store_clear(self):
-        """index_all() 应在索引笔记前调用 vector_store.clear()"""
+    def test_index_all_calls_vector_store_reset_collection(self):
+        """index_all() 应在索引笔记前调用 vector_store.reset_collection()"""
         from jfox.indexer import Indexer
 
         mock_config = MagicMock()
@@ -29,10 +29,10 @@ class TestIndexerClearBeforeRebuild:
             count = indexer.index_all()
 
             assert count == 0
-            mock_vector_store.clear.assert_called_once()
+            mock_vector_store.reset_collection.assert_called_once()
 
-    def test_index_all_clear_before_add(self):
-        """clear() 必须在 add_or_update_note() 之前调用"""
+    def test_index_all_reset_before_add(self):
+        """reset_collection() 必须在 add_or_update_note() 之前调用"""
         from jfox.indexer import Indexer
 
         mock_config = MagicMock()
@@ -59,11 +59,11 @@ class TestIndexerClearBeforeRebuild:
 
             # 验证调用顺序
             calls = mock_vector_store.method_calls
-            clear_indices = [i for i, c in enumerate(calls) if c[0] == "clear"]
+            reset_indices = [i for i, c in enumerate(calls) if c[0] == "reset_collection"]
             add_indices = [i for i, c in enumerate(calls) if c[0] == "add_or_update_note"]
 
-            if clear_indices and add_indices:
-                assert clear_indices[0] < add_indices[0], (
-                    f"clear() (call #{clear_indices[0]}) must be before "
+            if reset_indices and add_indices:
+                assert reset_indices[0] < add_indices[0], (
+                    f"reset_collection() (call #{reset_indices[0]}) must be before "
                     f"add_or_update_note() (call #{add_indices[0]})"
                 )

jfox_cli-0.4.1/tests/unit/test_vector_store_clear.py

@@ -0,0 +1,213 @@
+"""
+测试 VectorStore.clear() 方法
+
+验证 rebuild 前清除旧数据的逻辑
+"""
+
+import logging
+from unittest.mock import MagicMock, patch
+
+import chromadb
+
+
+class TestVectorStoreClear:
+    """VectorStore.clear() 单元测试"""
+
+    def test_clear_removes_all_documents(self):
+        """clear() 应删除 collection 中所有文档"""
+        from jfox.vector_store import VectorStore
+
+        store = VectorStore()
+        # 使用 EphemeralClient 避免文件锁，手动设置 client 和 collection
+        client = chromadb.EphemeralClient()
+        store.client = client
+        store.collection = client.create_collection(
+            name="test_clear", metadata={"hnsw:space": "cosine"}
+        )
+
+        # 插入 mock 数据（跳过 embedding，直接操作 collection）
+        store.collection.add(
+            ids=["note_001", "note_002", "note_003"],
+            documents=["doc1", "doc2", "doc3"],
+            embeddings=[[0.1] * 384, [0.2] * 384, [0.3] * 384],
+            metadatas=[
+                {"title": "t1", "type": "permanent", "filepath": "/a", "tags": ""},
+                {"title": "t2", "type": "permanent", "filepath": "/b", "tags": ""},
+                {"title": "t3", "type": "permanent", "filepath": "/c", "tags": ""},
+            ],
+        )
+
+        assert store.collection.count() == 3
+
+        # 清除
+        result = store.clear()
+
+        assert result is True
+        assert store.collection.count() == 0
+
+    def test_clear_on_empty_collection(self):
+        """clear() 在空 collection 上应正常返回 True"""
+        from jfox.vector_store import VectorStore
+
+        store = VectorStore()
+        client = chromadb.EphemeralClient()
+        store.client = client
+        store.collection = client.create_collection(
+            name="test_empty", metadata={"hnsw:space": "cosine"}
+        )
+
+        assert store.collection.count() == 0
+
+        result = store.clear()
+
+        assert result is True
+        assert store.collection.count() == 0
+
+    def test_clear_returns_false_on_failure(self):
+        """clear() 在异常时应返回 False 而非抛出"""
+        from jfox.vector_store import VectorStore
+
+        store = VectorStore()
+        # mock 一个会抛异常的 collection
+        store.collection = MagicMock()
+        store.collection.get.side_effect = Exception("DB error")
+
+        result = store.clear()
+
+        assert result is False
+
+
+class TestVectorStoreResetCollection:
+    """VectorStore.reset_collection() 单元测试"""
+
+    def test_reset_collection_recreates_collection(self):
+        """reset_collection() 应删除旧 collection 并创建新的（维度重置）"""
+        from jfox.vector_store import VectorStore
+
+        store = VectorStore()
+        client = chromadb.EphemeralClient()
+        store.client = client
+        store.collection = client.create_collection(name="notes", metadata={"hnsw:space": "cosine"})
+
+        # 插入 384 维数据
+        store.collection.add(
+            ids=["note_001"],
+            documents=["doc1"],
+            embeddings=[[0.1] * 384],
+            metadatas=[{"title": "t1", "type": "permanent", "filepath": "/a", "tags": ""}],
+        )
+        assert store.collection.count() == 1
+
+        # reset 后 collection 应为空
+        result = store.reset_collection()
+
+        assert result is True
+        assert store.collection.count() == 0
+
+    def test_reset_collection_on_nonexistent_collection(self):
+        """reset_collection() 在 collection 不存在时应正常创建新的"""
+        from jfox.vector_store import VectorStore
+
+        store = VectorStore()
+        client = chromadb.EphemeralClient()
+        store.client = client
+        # 不创建 collection，client 上没有 "notes" collection
+
+        result = store.reset_collection()
+
+        assert result is True
+        assert store.collection is not None
+        assert store.collection.count() == 0
+
+    def test_reset_collection_returns_false_on_recreate_failure(self):
+        """get_or_create_collection 失败时返回 False"""
+        from jfox.vector_store import VectorStore
+
+        store = VectorStore()
+        store.client = MagicMock()
+        store.client.delete_collection.return_value = None
+        store.client.get_or_create_collection.side_effect = Exception("DB error")
+
+        result = store.reset_collection()
+
+        assert result is False
+
+    def test_reset_collection_propagates_delete_failure(self):
+        """delete_collection 非预期异常应向上冒泡（如文件锁、磁盘错误）"""
+        import pytest
+
+        from jfox.vector_store import VectorStore
+
+        store = VectorStore()
+        store.client = MagicMock()
+        # 非 ValueError 的异常（如文件锁）不应被静默吞掉
+        store.client.delete_collection.side_effect = RuntimeError("file locked")
+
+        with pytest.raises(RuntimeError, match="file locked"):
+            store.reset_collection()
+
+
+class TestVectorStoreDimensionMismatch:
+    """add_note() 维度不匹配时应给出友好提示"""
+
+    def test_add_note_dimension_mismatch_friendly_message(self):
+        """维度不匹配时 logger.error 应包含 rebuild 提示"""
+        from jfox.vector_store import VectorStore
+
+        store = VectorStore()
+        client = chromadb.EphemeralClient()
+        store.client = client
+        store.collection = client.create_collection(
+            name="test_dim_mismatch", metadata={"hnsw:space": "cosine"}
+        )
+
+        # 创建一个假笔记
+        note = MagicMock()
+        note.id = "20260412120000"
+        note.title = "Test"
+        note.content = "Test content"
+        note.type = MagicMock(value="permanent")
+        note.tags = []
+        note.filepath = MagicMock()
+
+        # mock collection.add 抛出维度不匹配异常
+        store.collection.add = MagicMock(
+            side_effect=Exception("Collection expecting embedding with dimension of 384, got 1024")
+        )
+
+        with patch("jfox.embedding_backend.get_backend") as mock_backend:
+            mock_backend.return_value.encode_single.return_value.tolist.return_value = [0.1] * 1024
+            with patch.object(logging.getLogger("jfox.vector_store"), "error") as mock_error:
+                result = store.add_note(note)
+
+        assert result is False
+        # 验证错误信息包含 rebuild 提示
+        error_msg = mock_error.call_args[0][0]
+        assert "jfox index rebuild" in error_msg
+        assert "384" in error_msg
+        assert "1024" in error_msg
+
+    def test_add_note_non_dimension_exception_unchanged(self):
+        """非维度不匹配的异常仍使用原始错误信息格式"""
+        from jfox.vector_store import VectorStore
+
+        store = VectorStore()
+        store.collection = MagicMock()
+        store.collection.add.side_effect = Exception("Some other error")
+
+        note = MagicMock()
+        note.id = "20260412120000"
+        note.title = "Test"
+        note.content = "Content"
+        note.type = MagicMock(value="permanent")
+        note.tags = []
+        note.filepath = MagicMock()
+
+        with patch("jfox.embedding_backend.get_backend") as mock_backend:
+            mock_backend.return_value.encode_single.return_value.tolist.return_value = [0.1] * 384
+            with patch.object(logging.getLogger("jfox.vector_store"), "error") as mock_error:
+                result = store.add_note(note)
+
+        assert result is False
+        error_msg = mock_error.call_args[0][0]
+        assert "rebuild" not in error_msg.lower()

{jfox_cli-0.4.0 → jfox_cli-0.4.1}/uv.lock

@@ -867,7 +867,7 @@ wheels = [
 
 [[package]]
 name = "jfox-cli"
-version = "0.4.0"
+version = "0.4.1"
 source = { editable = "." }
 dependencies = [
     { name = "chromadb" },

jfox_cli-0.4.0/tests/unit/test_vector_store_clear.py

@@ -1,76 +0,0 @@
-"""
-测试 VectorStore.clear() 方法
-
-验证 rebuild 前清除旧数据的逻辑
-"""
-
-from unittest.mock import MagicMock
-
-import chromadb
-
-
-class TestVectorStoreClear:
-    """VectorStore.clear() 单元测试"""
-
-    def test_clear_removes_all_documents(self):
-        """clear() 应删除 collection 中所有文档"""
-        from jfox.vector_store import VectorStore
-
-        store = VectorStore()
-        # 使用 EphemeralClient 避免文件锁，手动设置 client 和 collection
-        client = chromadb.EphemeralClient()
-        store.client = client
-        store.collection = client.create_collection(
-            name="test_clear", metadata={"hnsw:space": "cosine"}
-        )
-
-        # 插入 mock 数据（跳过 embedding，直接操作 collection）
-        store.collection.add(
-            ids=["note_001", "note_002", "note_003"],
-            documents=["doc1", "doc2", "doc3"],
-            embeddings=[[0.1] * 384, [0.2] * 384, [0.3] * 384],
-            metadatas=[
-                {"title": "t1", "type": "permanent", "filepath": "/a", "tags": ""},
-                {"title": "t2", "type": "permanent", "filepath": "/b", "tags": ""},
-                {"title": "t3", "type": "permanent", "filepath": "/c", "tags": ""},
-            ],
-        )
-
-        assert store.collection.count() == 3
-
-        # 清除
-        result = store.clear()
-
-        assert result is True
-        assert store.collection.count() == 0
-
-    def test_clear_on_empty_collection(self):
-        """clear() 在空 collection 上应正常返回 True"""
-        from jfox.vector_store import VectorStore
-
-        store = VectorStore()
-        client = chromadb.EphemeralClient()
-        store.client = client
-        store.collection = client.create_collection(
-            name="test_empty", metadata={"hnsw:space": "cosine"}
-        )
-
-        assert store.collection.count() == 0
-
-        result = store.clear()
-
-        assert result is True
-        assert store.collection.count() == 0
-
-    def test_clear_returns_false_on_failure(self):
-        """clear() 在异常时应返回 False 而非抛出"""
-        from jfox.vector_store import VectorStore
-
-        store = VectorStore()
-        # mock 一个会抛异常的 collection
-        store.collection = MagicMock()
-        store.collection.get.side_effect = Exception("DB error")
-
-        result = store.clear()
-
-        assert result is False