jfox-cli 0.1.0__py3-none-any.whl

jfox/config.py

@@ -0,0 +1,180 @@
+"""配置管理"""
+
+import os
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+
+def get_default_kb_path() -> Path:
+    """获取默认知识库路径（从全局配置）"""
+    try:
+        from .global_config import get_global_config_manager
+        return get_global_config_manager().get_default_kb_path()
+    except Exception:
+        return Path.home() / ".zettelkasten"
+
+
+@dataclass
+class ZKConfig:
+    """Zettelkasten 配置"""
+    # 路径
+    base_dir: Path = field(default_factory=get_default_kb_path)
+    notes_dir: Path = field(init=False)
+    zk_dir: Path = field(init=False)
+    chroma_dir: Path = field(init=False)
+    
+    # NPU 配置
+    embedding_model: str = "sentence-transformers/all-MiniLM-L6-v2"
+    embedding_dimension: int = 384
+    device: str = "auto"  # auto / npu / gpu / cpu
+    batch_size: int = 32
+    
+    # 检索配置
+    default_semantic_top: int = 5
+    default_graph_hops: int = 2
+    similarity_threshold: float = 0.7
+    
+    # 同步配置
+    auto_sync: bool = True
+    sync_interval: int = 30  # 秒
+    
+    def __post_init__(self):
+        self.notes_dir = self.base_dir / "notes"
+        self.zk_dir = self.base_dir / ".zk"
+        self.chroma_dir = self.zk_dir / "chroma_db"
+        
+    def ensure_dirs(self):
+        """确保目录存在"""
+        dirs = [
+            self.notes_dir / "fleeting",
+            self.notes_dir / "literature", 
+            self.notes_dir / "permanent",
+            self.zk_dir,
+            self.chroma_dir,
+            self.zk_dir / "cache",
+        ]
+        for d in dirs:
+            d.mkdir(parents=True, exist_ok=True)
+    
+    def save(self, path: Optional[Path] = None):
+        """保存配置到文件"""
+        if path is None:
+            path = self.zk_dir / "config.yaml"
+        
+        config_dict = {
+            "base_dir": str(self.base_dir),
+            "embedding_model": self.embedding_model,
+            "embedding_dimension": self.embedding_dimension,
+            "device": self.device,
+            "batch_size": self.batch_size,
+            "default_semantic_top": self.default_semantic_top,
+            "default_graph_hops": self.default_graph_hops,
+            "similarity_threshold": self.similarity_threshold,
+            "auto_sync": self.auto_sync,
+            "sync_interval": self.sync_interval,
+        }
+        
+        with open(path, 'w', encoding='utf-8') as f:
+            yaml.dump(config_dict, f, allow_unicode=True, sort_keys=False)
+    
+    @classmethod
+    def load(cls, path: Optional[Path] = None) -> "ZKConfig":
+        """从文件加载配置"""
+        # 首先获取默认知识库路径
+        default_path = get_default_kb_path()
+        
+        if path is None:
+            path = default_path / ".zk" / "config.yaml"
+        
+        if not path.exists():
+            return cls(base_dir=default_path)
+        
+        with open(path, 'r', encoding='utf-8') as f:
+            config_dict = yaml.safe_load(f)
+        
+        # 转换路径
+        if 'base_dir' in config_dict:
+            config_dict['base_dir'] = Path(config_dict['base_dir'])
+        else:
+            config_dict['base_dir'] = default_path
+        
+        return cls(**config_dict)
+
+    @classmethod
+    def for_kb(cls, kb_path: Path) -> "ZKConfig":
+        """为指定知识库创建配置"""
+        return cls(base_dir=kb_path)
+
+
+# 全局配置实例（动态获取当前默认知识库）
+def get_config() -> ZKConfig:
+    """获取当前默认知识库的配置"""
+    return ZKConfig.load()
+
+
+# 为了向后兼容，保留 config 变量，但使用动态获取
+config = get_config()
+
+
+@contextmanager
+def use_kb(kb_name: Optional[str] = None):
+    """
+    临时使用指定知识库的上下文管理器
+    
+    用法:
+        with use_kb("work"):
+            # 在这个上下文中，操作都在 work 知识库上
+            note = create_note(...)
+    
+    Args:
+        kb_name: 知识库名称，None 表示使用当前默认知识库
+        
+    Raises:
+        ValueError: 知识库不存在
+    """
+    if not kb_name:
+        yield
+        return
+    
+    from .kb_manager import get_kb_manager
+    manager = get_kb_manager()
+    
+    if not manager.config_manager.kb_exists(kb_name):
+        raise ValueError(f"Knowledge base '{kb_name}' not found")
+    
+    # 保存原始配置
+    original_base_dir = config.base_dir
+    original_notes_dir = config.notes_dir
+    original_zk_dir = config.zk_dir
+    original_chroma_dir = config.chroma_dir
+    
+    try:
+        # 切换到目标知识库
+        kb_path = manager.config_manager.get_kb_path(kb_name)
+        config.base_dir = kb_path
+        config.notes_dir = kb_path / "notes"
+        config.zk_dir = kb_path / ".zk"
+        config.chroma_dir = config.zk_dir / "chroma_db"
+        
+        # 重置索引和搜索引擎（使用新的知识库路径）
+        try:
+            from .bm25_index import reset_bm25_index
+            from .search_engine import reset_search_engine
+            from .vector_store import reset_vector_store
+            reset_bm25_index()
+            reset_search_engine()
+            reset_vector_store()
+        except Exception:
+            pass  # 忽略重置错误
+        
+        yield
+    finally:
+        # 恢复原始配置
+        config.base_dir = original_base_dir
+        config.notes_dir = original_notes_dir
+        config.zk_dir = original_zk_dir
+        config.chroma_dir = original_chroma_dir

jfox/embedding_backend.py

@@ -0,0 +1,65 @@
+"""Embedding Backend - CPU Only (Simplified)"""
+
+import logging
+from typing import List, Optional
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+class EmbeddingBackend:
+    """Simple CPU-based embedding backend"""
+    
+    def __init__(self, model_name: str = "sentence-transformers/all-MiniLM-L6-v2"):
+        self.model_name = model_name
+        self.model = None
+        
+    def load(self):
+        """Load the model"""
+        if self.model is not None:
+            return
+            
+        try:
+            from sentence_transformers import SentenceTransformer
+            self.model = SentenceTransformer(self.model_name)
+            logger.info(f"Model loaded: {self.model_name}")
+        except Exception as e:
+            logger.error(f"Failed to load model: {e}")
+            raise
+    
+    def encode(self, texts: List[str], batch_size: int = 32) -> np.ndarray:
+        """Encode texts to embeddings"""
+        if self.model is None:
+            self.load()
+            
+        try:
+            return self.model.encode(
+                texts, 
+                batch_size=batch_size, 
+                show_progress_bar=False,
+                convert_to_numpy=True
+            )
+        except Exception as e:
+            logger.error(f"Encoding failed: {e}")
+            raise
+    
+    def encode_single(self, text: str) -> np.ndarray:
+        """Encode a single text"""
+        return self.encode([text])[0]
+    
+    @property
+    def dimension(self) -> int:
+        """Return embedding dimension"""
+        return 384
+
+
+# Global backend instance
+_backend: Optional[EmbeddingBackend] = None
+
+
+def get_backend() -> EmbeddingBackend:
+    """Get global embedding backend instance"""
+    global _backend
+    if _backend is None:
+        _backend = EmbeddingBackend()
+    return _backend

jfox/formatters.py

@@ -0,0 +1,305 @@
+"""
+输出格式化器
+
+支持多种输出格式：json, table, csv, yaml, paths, tree
+"""
+
+import csv
+import io
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+import yaml
+from rich.console import Console
+from rich.table import Table
+from rich.tree import Tree
+
+
+class OutputFormatter:
+    """输出格式化器"""
+    
+    SUPPORTED_FORMATS = ["json", "table", "csv", "yaml", "paths", "tree"]
+    
+    @classmethod
+    def format(cls, data: Any, format_type: str, **kwargs) -> str:
+        """
+        根据格式类型格式化数据
+        
+        Args:
+            data: 要格式化的数据
+            format_type: 格式类型
+            **kwargs: 额外参数
+            
+        Returns:
+            格式化后的字符串
+            
+        Raises:
+            ValueError: 不支持的格式
+        """
+        format_type = format_type.lower()
+        
+        if format_type == "json":
+            return cls.to_json(data)
+        elif format_type == "table":
+            return cls.to_table(data, **kwargs)
+        elif format_type == "csv":
+            return cls.to_csv(data, **kwargs)
+        elif format_type == "yaml":
+            return cls.to_yaml(data)
+        elif format_type == "paths":
+            return cls.to_paths(data)
+        elif format_type == "tree":
+            return cls.to_tree(data, **kwargs)
+        else:
+            raise ValueError(f"Unsupported format: {format_type}. "
+                           f"Supported: {', '.join(cls.SUPPORTED_FORMATS)}")
+    
+    @staticmethod
+    def to_json(data: Any) -> str:
+        """
+        JSON 格式
+        
+        Args:
+            data: 任意可序列化数据
+            
+        Returns:
+            JSON 字符串
+        """
+        return json.dumps(data, ensure_ascii=False, indent=2, default=str)
+    
+    @staticmethod
+    def to_csv(data: List[Dict], headers: Optional[List[str]] = None) -> str:
+        """
+        CSV 格式
+        
+        Args:
+            data: 字典列表
+            headers: 自定义表头，None 则使用所有键
+            
+        Returns:
+            CSV 字符串
+        """
+        if not data:
+            return ""
+        
+        # 确定表头
+        if headers is None:
+            if isinstance(data[0], dict):
+                headers = list(data[0].keys())
+            else:
+                return ""
+        
+        # 创建 CSV
+        output = io.StringIO()
+        writer = csv.DictWriter(
+            output,
+            fieldnames=headers,
+            extrasaction='ignore',
+            quoting=csv.QUOTE_MINIMAL
+        )
+        writer.writeheader()
+        
+        for row in data:
+            if isinstance(row, dict):
+                # 处理嵌套字典和列表
+                flat_row = {}
+                for key, value in row.items():
+                    if isinstance(value, (list, dict)):
+                        flat_row[key] = json.dumps(value, ensure_ascii=False)
+                    else:
+                        flat_row[key] = value
+                writer.writerow(flat_row)
+        
+        return output.getvalue()
+    
+    @staticmethod
+    def to_yaml(data: Any) -> str:
+        """
+        YAML 格式
+        
+        Args:
+            data: 任意可序列化数据
+            
+        Returns:
+            YAML 字符串
+        """
+        return yaml.dump(
+            data,
+            allow_unicode=True,
+            sort_keys=False,
+            default_flow_style=False,
+            indent=2
+        )
+    
+    @staticmethod
+    def to_paths(data: Union[List[Dict], List[Path], List[str]], 
+                 key: str = "filepath") -> str:
+        """
+        路径格式 - 每行一个路径
+        
+        Args:
+            data: 数据列表
+            key: 路径字段名
+            
+        Returns:
+            路径字符串，每行一个
+        """
+        if not data:
+            return ""
+        
+        paths = []
+        for item in data:
+            if isinstance(item, (str, Path)):
+                paths.append(str(item))
+            elif isinstance(item, dict):
+                path = item.get(key)
+                if path:
+                    paths.append(str(path))
+        
+        return "\n".join(paths)
+    
+    @staticmethod
+    def to_table(data: List[Dict], 
+                 columns: Optional[List[str]] = None,
+                 title: Optional[str] = None) -> str:
+        """
+        表格格式（使用 Rich）
+        
+        注意：此函数返回的字符串需要通过 rich.console 渲染
+        
+        Args:
+            data: 字典列表
+            columns: 显示的列，None 则显示所有
+            title: 表格标题
+            
+        Returns:
+            表格对象（特殊处理，需要渲染）
+        """
+        if not data:
+            return "(No data)"
+        
+        # 确定列
+        if columns is None:
+            if isinstance(data[0], dict):
+                columns = list(data[0].keys())
+            else:
+                return str(data)
+        
+        # 创建表格
+        table = Table(title=title)
+        for col in columns:
+            table.add_column(str(col), overflow="fold")
+        
+        # 添加行
+        for row in data:
+            if isinstance(row, dict):
+                values = []
+                for col in columns:
+                    val = row.get(col, "")
+                    # 处理复杂类型
+                    if isinstance(val, (list, dict)):
+                        val = json.dumps(val, ensure_ascii=False)[:50]
+                    elif isinstance(val, Path):
+                        val = str(val)
+                    values.append(str(val) if val is not None else "")
+                table.add_row(*values)
+        
+        # 渲染为字符串
+        console = Console(file=io.StringIO(), force_terminal=False)
+        console.print(table)
+        return console.file.getvalue()
+    
+    @staticmethod
+    def to_tree(data: List[Dict],
+                root_name: str = "notes",
+                group_by: str = "type") -> str:
+        """
+        树形格式
+        
+        Args:
+            data: 笔记数据列表
+            root_name: 根节点名称
+            group_by: 分组字段
+            
+        Returns:
+            树形字符串
+        """
+        if not data:
+            return f"{root_name}/"
+        
+        # 按类型分组
+        groups: Dict[str, List[Dict]] = {}
+        for item in data:
+            if isinstance(item, dict):
+                group_key = str(item.get(group_by, "unknown"))
+                if group_key not in groups:
+                    groups[group_key] = []
+                groups[group_key].append(item)
+        
+        # 创建树
+        tree = Tree(f"[bold]{root_name}/[/bold]")
+        
+        for group_name, items in sorted(groups.items()):
+            group_node = tree.add(f"[cyan]{group_name}/[/cyan]")
+            for item in items:
+                title = item.get("title", "Untitled")
+                note_id = item.get("id", "")
+                if note_id:
+                    group_node.add(f"{title} ([dim]{note_id}[/dim])")
+                else:
+                    group_node.add(title)
+        
+        # 渲染为字符串
+        console = Console(file=io.StringIO(), force_terminal=False)
+        console.print(tree)
+        return console.file.getvalue()
+
+
+def format_output(data: Any, 
+                  format_type: str, 
+                  console: Optional[Console] = None,
+                  **kwargs) -> None:
+    """
+    格式化并输出数据
+    
+    Args:
+        data: 要格式化的数据
+        format_type: 格式类型
+        console: Rich console 实例，None 则创建新实例
+        **kwargs: 额外参数传递给 formatter
+    """
+    if console is None:
+        console = Console()
+    
+    if format_type == "table":
+        # table 格式需要特殊处理
+        output = OutputFormatter.to_table(data, **kwargs)
+        if output == "(No data)":
+            console.print(output)
+        else:
+            # 重新渲染表格（因为 to_table 已经返回了渲染后的字符串）
+            console.print(output)
+    elif format_type == "tree":
+        output = OutputFormatter.to_tree(data, **kwargs)
+        console.print(output)
+    else:
+        output = OutputFormatter.format(data, format_type, **kwargs)
+        console.print(output)
+
+
+# 向后兼容：支持 --json 参数
+def is_json_format(json_flag: bool, format_param: Optional[str]) -> bool:
+    """
+    判断是否使用 JSON 格式（向后兼容）
+    
+    Args:
+        json_flag: --json 标志
+        format_param: --format 参数值
+        
+    Returns:
+        是否使用 JSON 格式
+    """
+    if format_param:
+        return format_param.lower() == "json"
+    return json_flag