yuho 5.0.0__py3-none-any.whl

yuho/config/__init__.py

@@ -0,0 +1,46 @@
+"""
+Yuho configuration module.
+
+Handles configuration loading from:
+1. Default values
+2. Config file (~/.config/yuho/config.toml)
+3. Environment variables (YUHO_*)
+4. CLI flags
+
+Later sources override earlier ones.
+"""
+
+from yuho.config.loader import Config, load_config, get_config
+from yuho.config.schema import (
+    LLMSection,
+    TranspileSection,
+    LSPSection,
+    MCPSection,
+)
+from yuho.config.mask import (
+    mask_value,
+    mask_dict,
+    mask_string,
+    mask_error,
+    mask_url,
+    safe_repr,
+    is_sensitive_key,
+)
+
+__all__ = [
+    "Config",
+    "load_config",
+    "get_config",
+    "LLMSection",
+    "TranspileSection",
+    "LSPSection",
+    "MCPSection",
+    # Masking utilities
+    "mask_value",
+    "mask_dict",
+    "mask_string",
+    "mask_error",
+    "mask_url",
+    "safe_repr",
+    "is_sensitive_key",
+]

yuho/config/loader.py

@@ -0,0 +1,235 @@
+"""
+Configuration loader with multi-source override support.
+
+Load order (later overrides earlier):
+1. Built-in defaults
+2. Config file (~/.config/yuho/config.toml)
+3. Environment variables (YUHO_*)
+4. CLI flags
+"""
+
+import os
+from pathlib import Path
+from typing import Optional, Dict, Any
+import logging
+
+from yuho.config.schema import ConfigSchema
+
+logger = logging.getLogger(__name__)
+
+# Default config file location
+DEFAULT_CONFIG_PATH = Path.home() / ".config" / "yuho" / "config.toml"
+
+# Singleton config instance
+_config: Optional["Config"] = None
+
+
+class Config:
+    """
+    Yuho configuration manager.
+
+    Handles loading and accessing configuration from multiple sources.
+    """
+
+    def __init__(self, schema: ConfigSchema):
+        self._schema = schema
+
+    @property
+    def llm(self):
+        """Get LLM configuration section."""
+        return self._schema.llm
+
+    @property
+    def transpile(self):
+        """Get transpile configuration section."""
+        return self._schema.transpile
+
+    @property
+    def lsp(self):
+        """Get LSP configuration section."""
+        return self._schema.lsp
+
+    @property
+    def mcp(self):
+        """Get MCP configuration section."""
+        return self._schema.mcp
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return self._schema.to_dict()
+
+
+def load_config(
+    config_path: Optional[Path] = None,
+    env_prefix: str = "YUHO_",
+    cli_overrides: Optional[Dict[str, Any]] = None,
+) -> Config:
+    """
+    Load configuration from all sources.
+
+    Args:
+        config_path: Path to config file (default: ~/.config/yuho/config.toml)
+        env_prefix: Prefix for environment variables
+        cli_overrides: Dictionary of CLI flag overrides
+
+    Returns:
+        Loaded Config instance
+    """
+    # Start with defaults
+    config_data: Dict[str, Any] = {}
+
+    # Load from file
+    file_path = config_path or DEFAULT_CONFIG_PATH
+    if file_path.exists():
+        config_data = _load_from_file(file_path)
+        logger.debug(f"Loaded config from {file_path}")
+
+    # Override from environment
+    env_data = _load_from_env(env_prefix)
+    config_data = _merge_dicts(config_data, env_data)
+
+    # Override from CLI
+    if cli_overrides:
+        config_data = _merge_dicts(config_data, cli_overrides)
+
+    # Create schema
+    schema = ConfigSchema.from_dict(config_data)
+
+    return Config(schema)
+
+
+def get_config() -> Config:
+    """
+    Get the global config instance.
+
+    Loads config on first call, then returns cached instance.
+    """
+    global _config
+    if _config is None:
+        _config = load_config()
+    return _config
+
+
+def _load_from_file(path: Path) -> Dict[str, Any]:
+    """Load config from TOML file."""
+    try:
+        import tomllib
+    except ImportError:
+        try:
+            import tomli as tomllib
+        except ImportError:
+            logger.warning("tomllib/tomli not available, skipping config file")
+            return {}
+
+    try:
+        with open(path, "rb") as f:
+            return tomllib.load(f)
+    except Exception as e:
+        logger.warning(f"Failed to load config file: {e}")
+        return {}
+
+
+def _load_from_env(prefix: str) -> Dict[str, Any]:
+    """Load config from environment variables."""
+    config: Dict[str, Any] = {}
+
+    # Map environment variables to config paths
+    env_mapping = {
+        f"{prefix}LLM_PROVIDER": ("llm", "provider"),
+        f"{prefix}LLM_MODEL": ("llm", "model"),
+        f"{prefix}LLM_OLLAMA_HOST": ("llm", "ollama_host"),
+        f"{prefix}LLM_OLLAMA_PORT": ("llm", "ollama_port"),
+        f"{prefix}LLM_HUGGINGFACE_CACHE": ("llm", "huggingface_cache"),
+        f"{prefix}LLM_OPENAI_API_KEY": ("llm", "openai_api_key"),
+        f"{prefix}LLM_ANTHROPIC_API_KEY": ("llm", "anthropic_api_key"),
+        f"{prefix}LLM_MAX_TOKENS": ("llm", "max_tokens"),
+        f"{prefix}LLM_TEMPERATURE": ("llm", "temperature"),
+        f"{prefix}TRANSPILE_DEFAULT_TARGET": ("transpile", "default_target"),
+        f"{prefix}TRANSPILE_LATEX_COMPILER": ("transpile", "latex_compiler"),
+        f"{prefix}TRANSPILE_OUTPUT_DIR": ("transpile", "output_dir"),
+        f"{prefix}MCP_HOST": ("mcp", "host"),
+        f"{prefix}MCP_PORT": ("mcp", "port"),
+        f"{prefix}MCP_AUTH_TOKEN": ("mcp", "auth_token"),
+    }
+
+    for env_var, (section, key) in env_mapping.items():
+        value = os.environ.get(env_var)
+        if value is not None:
+            if section not in config:
+                config[section] = {}
+
+            # Type conversion
+            if key in ("ollama_port", "max_tokens", "port"):
+                value = int(value)
+            elif key == "temperature":
+                value = float(value)
+
+            config[section][key] = value
+
+    return config
+
+
+def _merge_dicts(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
+    """Deep merge two dictionaries."""
+    result = base.copy()
+
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _merge_dicts(result[key], value)
+        else:
+            result[key] = value
+
+    return result
+
+
+def create_default_config(path: Optional[Path] = None) -> Path:
+    """
+    Create a default config file.
+
+    Args:
+        path: Path to create file at (default: ~/.config/yuho/config.toml)
+
+    Returns:
+        Path to created file
+    """
+    file_path = path or DEFAULT_CONFIG_PATH
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+
+    default_config = """# Yuho Configuration
+# https://yuho.dev/docs/configuration
+
+[llm]
+# LLM provider: ollama, huggingface, openai, anthropic
+provider = "ollama"
+model = "llama3"
+ollama_host = "localhost"
+ollama_port = 11434
+# huggingface_cache = "~/.cache/huggingface"
+# openai_api_key = ""
+# anthropic_api_key = ""
+max_tokens = 2048
+temperature = 0.7
+fallback_providers = ["huggingface"]
+
+[transpile]
+default_target = "json"
+latex_compiler = "pdflatex"
+# output_dir = "./output"
+include_source_locations = true
+
+[lsp]
+diagnostic_severity_error = true
+diagnostic_severity_warning = true
+diagnostic_severity_info = true
+diagnostic_severity_hint = true
+completion_trigger_chars = [".", ":"]
+
+[mcp]
+host = "127.0.0.1"
+port = 8080
+allowed_origins = ["*"]
+# auth_token = ""
+"""
+
+    file_path.write_text(default_config)
+    return file_path

yuho/config/mask.py

@@ -0,0 +1,194 @@
+"""
+Utilities for masking sensitive data in logs, errors, and output.
+
+This module provides functions to redact sensitive information like
+API keys, tokens, and passwords before they appear in logs or error messages.
+"""
+
+import re
+from typing import Any, Dict, List, Optional, Set
+
+# Sensitive field names that should always be masked
+SENSITIVE_FIELDS: Set[str] = {
+    "api_key",
+    "apikey",
+    "api-key",
+    "auth_token",
+    "authtoken",
+    "auth-token",
+    "token",
+    "password",
+    "secret",
+    "credential",
+    "openai_api_key",
+    "anthropic_api_key",
+    "authorization",
+    "bearer",
+}
+
+# Patterns that look like secrets (for string scanning)
+SECRET_PATTERNS = [
+    # API keys (various formats)
+    re.compile(r"sk-[a-zA-Z0-9]{20,}"),  # OpenAI-style
+    re.compile(r"sk-ant-[a-zA-Z0-9-]{20,}"),  # Anthropic-style
+    re.compile(r"hf_[a-zA-Z0-9]{20,}"),  # HuggingFace-style
+    # Bearer tokens in headers
+    re.compile(r"Bearer\s+[a-zA-Z0-9._-]{20,}", re.IGNORECASE),
+    # Generic long alphanumeric strings that look like tokens
+    re.compile(r"[a-zA-Z0-9]{32,}"),
+]
+
+
+def mask_value(value: str, visible_chars: int = 4) -> str:
+    """
+    Mask a sensitive value, showing only the first few characters.
+
+    Args:
+        value: The sensitive value to mask
+        visible_chars: Number of characters to show at the start
+
+    Returns:
+        Masked value like "sk-a***" or "***" if too short
+    """
+    if not value or len(value) <= visible_chars:
+        return "***"
+    return value[:visible_chars] + "***"
+
+
+def is_sensitive_key(key: str) -> bool:
+    """
+    Check if a key name indicates sensitive data.
+
+    Args:
+        key: The key/field name to check
+
+    Returns:
+        True if the key appears to be sensitive
+    """
+    key_lower = key.lower().replace("_", "").replace("-", "")
+    for sensitive in SENSITIVE_FIELDS:
+        if sensitive.replace("_", "").replace("-", "") in key_lower:
+            return True
+    return False
+
+
+def mask_dict(data: Dict[str, Any], deep: bool = True) -> Dict[str, Any]:
+    """
+    Mask sensitive values in a dictionary.
+
+    Args:
+        data: Dictionary potentially containing sensitive values
+        deep: Whether to recursively mask nested dictionaries
+
+    Returns:
+        New dictionary with sensitive values masked
+    """
+    result = {}
+    for key, value in data.items():
+        if is_sensitive_key(key):
+            if isinstance(value, str) and value:
+                result[key] = mask_value(value)
+            elif value is not None:
+                result[key] = "***"
+            else:
+                result[key] = None
+        elif deep and isinstance(value, dict):
+            result[key] = mask_dict(value, deep=True)
+        elif deep and isinstance(value, list):
+            result[key] = [
+                mask_dict(v, deep=True) if isinstance(v, dict) else v
+                for v in value
+            ]
+        else:
+            result[key] = value
+    return result
+
+
+def mask_string(text: str) -> str:
+    """
+    Scan a string and mask anything that looks like a secret.
+
+    Args:
+        text: Text that might contain secrets
+
+    Returns:
+        Text with secret-like patterns masked
+    """
+    result = text
+    for pattern in SECRET_PATTERNS:
+        result = pattern.sub(lambda m: mask_value(m.group(0)), result)
+    return result
+
+
+def mask_error(error: Exception) -> str:
+    """
+    Get a safe string representation of an error, masking any secrets.
+
+    Args:
+        error: The exception to format
+
+    Returns:
+        Error message with potential secrets masked
+    """
+    return mask_string(str(error))
+
+
+def mask_url(url: str) -> str:
+    """
+    Mask sensitive parts of a URL (query params with sensitive names).
+
+    Args:
+        url: URL that might contain sensitive query parameters
+
+    Returns:
+        URL with sensitive query parameters masked
+    """
+    from urllib.parse import urlparse, parse_qs, urlencode, urlunparse
+
+    try:
+        parsed = urlparse(url)
+        if not parsed.query:
+            return url
+
+        params = parse_qs(parsed.query, keep_blank_values=True)
+        masked_params = {}
+
+        for key, values in params.items():
+            if is_sensitive_key(key):
+                masked_params[key] = ["***" for _ in values]
+            else:
+                masked_params[key] = values
+
+        # Rebuild URL with masked params
+        masked_query = urlencode(masked_params, doseq=True)
+        return urlunparse((
+            parsed.scheme,
+            parsed.netloc,
+            parsed.path,
+            parsed.params,
+            masked_query,
+            parsed.fragment,
+        ))
+    except Exception:
+        # If URL parsing fails, just return original
+        return url
+
+
+def safe_repr(obj: Any) -> str:
+    """
+    Get a safe string representation of any object, masking secrets.
+
+    Args:
+        obj: Object to represent
+
+    Returns:
+        Safe string representation
+    """
+    if isinstance(obj, dict):
+        return str(mask_dict(obj))
+    elif isinstance(obj, str):
+        return mask_string(obj)
+    elif isinstance(obj, Exception):
+        return mask_error(obj)
+    else:
+        return mask_string(repr(obj))

yuho/config/schema.py

@@ -0,0 +1,147 @@
+"""
+Configuration schema definitions.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional, List, Dict, Any
+from pathlib import Path
+
+
+@dataclass
+class LLMSection:
+    """[llm] configuration section."""
+
+    provider: str = "ollama"
+    model: str = "llama3"
+    ollama_host: str = "localhost"
+    ollama_port: int = 11434
+    huggingface_cache: Optional[str] = None
+    openai_api_key: Optional[str] = None
+    anthropic_api_key: Optional[str] = None
+    max_tokens: int = 2048
+    temperature: float = 0.7
+    fallback_providers: List[str] = field(default_factory=lambda: ["huggingface"])
+
+    def to_llm_config(self):
+        """Convert to LLMConfig."""
+        from yuho.llm import LLMConfig
+        return LLMConfig(
+            provider=self.provider,
+            model_name=self.model,
+            ollama_host=self.ollama_host,
+            ollama_port=self.ollama_port,
+            huggingface_cache=self.huggingface_cache,
+            api_key=self.openai_api_key or self.anthropic_api_key,
+            max_tokens=self.max_tokens,
+            temperature=self.temperature,
+            fallback_providers=self.fallback_providers,
+        )
+
+
+@dataclass
+class TranspileSection:
+    """[transpile] configuration section."""
+
+    default_target: str = "json"
+    latex_compiler: str = "pdflatex"
+    output_dir: Optional[str] = None
+    include_source_locations: bool = True
+
+
+@dataclass
+class LSPSection:
+    """[lsp] configuration section."""
+
+    diagnostic_severity_error: bool = True
+    diagnostic_severity_warning: bool = True
+    diagnostic_severity_info: bool = True
+    diagnostic_severity_hint: bool = True
+    completion_trigger_chars: List[str] = field(default_factory=lambda: [".", ":"])
+
+
+@dataclass
+class MCPSection:
+    """[mcp] configuration section."""
+
+    host: str = "127.0.0.1"
+    port: int = 8080
+    allowed_origins: List[str] = field(default_factory=lambda: ["*"])
+    auth_token: Optional[str] = None
+
+
+@dataclass
+class LibrarySection:
+    """[library] configuration section."""
+
+    registry_url: str = "https://registry.yuho.dev"
+    registry_api_version: str = "v1"
+    auth_token: Optional[str] = None
+    timeout: int = 30
+    verify_ssl: bool = True
+
+
+@dataclass
+class ConfigSchema:
+    """Complete configuration schema."""
+
+    llm: LLMSection = field(default_factory=LLMSection)
+    transpile: TranspileSection = field(default_factory=TranspileSection)
+    lsp: LSPSection = field(default_factory=LSPSection)
+    mcp: MCPSection = field(default_factory=MCPSection)
+    library: LibrarySection = field(default_factory=LibrarySection)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ConfigSchema":
+        """Create config from dictionary."""
+        llm_data = data.get("llm", {})
+        transpile_data = data.get("transpile", {})
+        lsp_data = data.get("lsp", {})
+        mcp_data = data.get("mcp", {})
+        library_data = data.get("library", {})
+
+        return cls(
+            llm=LLMSection(**{k: v for k, v in llm_data.items() if k in LLMSection.__dataclass_fields__}),
+            transpile=TranspileSection(**{k: v for k, v in transpile_data.items() if k in TranspileSection.__dataclass_fields__}),
+            lsp=LSPSection(**{k: v for k, v in lsp_data.items() if k in LSPSection.__dataclass_fields__}),
+            mcp=MCPSection(**{k: v for k, v in mcp_data.items() if k in MCPSection.__dataclass_fields__}),
+            library=LibrarySection(**{k: v for k, v in library_data.items() if k in LibrarySection.__dataclass_fields__}),
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "llm": {
+                "provider": self.llm.provider,
+                "model": self.llm.model,
+                "ollama_host": self.llm.ollama_host,
+                "ollama_port": self.llm.ollama_port,
+                "huggingface_cache": self.llm.huggingface_cache,
+                "max_tokens": self.llm.max_tokens,
+                "temperature": self.llm.temperature,
+                "fallback_providers": self.llm.fallback_providers,
+            },
+            "transpile": {
+                "default_target": self.transpile.default_target,
+                "latex_compiler": self.transpile.latex_compiler,
+                "output_dir": self.transpile.output_dir,
+                "include_source_locations": self.transpile.include_source_locations,
+            },
+            "lsp": {
+                "diagnostic_severity_error": self.lsp.diagnostic_severity_error,
+                "diagnostic_severity_warning": self.lsp.diagnostic_severity_warning,
+                "diagnostic_severity_info": self.lsp.diagnostic_severity_info,
+                "diagnostic_severity_hint": self.lsp.diagnostic_severity_hint,
+                "completion_trigger_chars": self.lsp.completion_trigger_chars,
+            },
+            "mcp": {
+                "host": self.mcp.host,
+                "port": self.mcp.port,
+                "allowed_origins": self.mcp.allowed_origins,
+            },
+            "library": {
+                "registry_url": self.library.registry_url,
+                "registry_api_version": self.library.registry_api_version,
+                "timeout": self.library.timeout,
+                "verify_ssl": self.library.verify_ssl,
+            },
+        }

yuho/library/__init__.py

@@ -0,0 +1,84 @@
+"""
+Yuho library module - user-contributed statute repository.
+
+Provides:
+- Package format definitions (.yhpkg)
+- Contribution validation
+- Library indexing and search
+- Package installation and management
+- Dependency resolution with version constraints
+"""
+
+from yuho.library.package import (
+    Package,
+    PackageMetadata,
+    PackageValidator,
+    DeprecationInfo,
+)
+from yuho.library.index import (
+    LibraryIndex,
+    search_library,
+)
+from yuho.library.install import (
+    install_package,
+    uninstall_package,
+    list_installed,
+    update_package,
+    check_updates,
+    download_package,
+    update_all_packages,
+    publish_package,
+)
+from yuho.library.resolver import (
+    DependencyResolver,
+    Resolution,
+    Dependency,
+    Version,
+    VersionConstraint,
+    resolve_dependencies,
+    validate_semver,
+    SemverValidation,
+    SemverValidationError,
+    CompatibilityChecker,
+    CompatibilityResult,
+)
+from yuho.library.lockfile import (
+    LockFile,
+    LockFileManager,
+    LockedPackage,
+    load_lock_file,
+    create_lock_file,
+)
+
+__all__ = [
+    "Package",
+    "PackageMetadata",
+    "PackageValidator",
+    "DeprecationInfo",
+    "LibraryIndex",
+    "search_library",
+    "install_package",
+    "uninstall_package",
+    "list_installed",
+    "update_package",
+    "check_updates",
+    "download_package",
+    "update_all_packages",
+    "publish_package",
+    "DependencyResolver",
+    "Resolution",
+    "Dependency",
+    "Version",
+    "VersionConstraint",
+    "resolve_dependencies",
+    "validate_semver",
+    "SemverValidation",
+    "SemverValidationError",
+    "CompatibilityChecker",
+    "CompatibilityResult",
+    "LockFile",
+    "LockFileManager",
+    "LockedPackage",
+    "load_lock_file",
+    "create_lock_file",
+]