claude-code-workflow 6.2.4 → 6.2.5

package/codex-lens/src/codexlens/cli/model_manager.py

@@ -1,289 +0,0 @@
-"""Model Manager - Manage fastembed models for semantic search."""
-
-import json
-import os
-import shutil
-from pathlib import Path
-from typing import Dict, List, Optional
-
-try:
-    from fastembed import TextEmbedding
-    FASTEMBED_AVAILABLE = True
-except ImportError:
-    FASTEMBED_AVAILABLE = False
-
-
-# Model profiles with metadata
-MODEL_PROFILES = {
-    "fast": {
-        "model_name": "BAAI/bge-small-en-v1.5",
-        "dimensions": 384,
-        "size_mb": 80,
-        "description": "Fast, lightweight, English-optimized",
-        "use_case": "Quick prototyping, resource-constrained environments",
-    },
-    "code": {
-        "model_name": "jinaai/jina-embeddings-v2-base-code",
-        "dimensions": 768,
-        "size_mb": 150,
-        "description": "Code-optimized, best for programming languages",
-        "use_case": "Open source projects, code semantic search",
-    },
-    "multilingual": {
-        "model_name": "intfloat/multilingual-e5-large",
-        "dimensions": 1024,
-        "size_mb": 1000,
-        "description": "Multilingual + code support",
-        "use_case": "Enterprise multilingual projects",
-    },
-    "balanced": {
-        "model_name": "mixedbread-ai/mxbai-embed-large-v1",
-        "dimensions": 1024,
-        "size_mb": 600,
-        "description": "High accuracy, general purpose",
-        "use_case": "High-quality semantic search, balanced performance",
-    },
-}
-
-
-def get_cache_dir() -> Path:
-    """Get fastembed cache directory.
-
-    Returns:
-        Path to cache directory (usually ~/.cache/fastembed or %LOCALAPPDATA%\\Temp\\fastembed_cache)
-    """
-    # Check HF_HOME environment variable first
-    if "HF_HOME" in os.environ:
-        return Path(os.environ["HF_HOME"])
-
-    # Default cache locations
-    if os.name == "nt":  # Windows
-        cache_dir = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData" / "Local")) / "Temp" / "fastembed_cache"
-    else:  # Unix-like
-        cache_dir = Path.home() / ".cache" / "fastembed"
-
-    return cache_dir
-
-
-def list_models() -> Dict[str, any]:
-    """List available model profiles and their installation status.
-
-    Returns:
-        Dictionary with model profiles, installed status, and cache info
-    """
-    if not FASTEMBED_AVAILABLE:
-        return {
-            "success": False,
-            "error": "fastembed not installed. Install with: pip install codexlens[semantic]",
-        }
-
-    cache_dir = get_cache_dir()
-    cache_exists = cache_dir.exists()
-
-    models = []
-    for profile, info in MODEL_PROFILES.items():
-        model_name = info["model_name"]
-
-        # Check if model is cached
-        installed = False
-        cache_size_mb = 0
-
-        if cache_exists:
-            # Check for model directory in cache
-            model_cache_path = cache_dir / f"models--{model_name.replace('/', '--')}"
-            if model_cache_path.exists():
-                installed = True
-                # Calculate cache size
-                total_size = sum(
-                    f.stat().st_size
-                    for f in model_cache_path.rglob("*")
-                    if f.is_file()
-                )
-                cache_size_mb = round(total_size / (1024 * 1024), 1)
-
-        models.append({
-            "profile": profile,
-            "model_name": model_name,
-            "dimensions": info["dimensions"],
-            "estimated_size_mb": info["size_mb"],
-            "actual_size_mb": cache_size_mb if installed else None,
-            "description": info["description"],
-            "use_case": info["use_case"],
-            "installed": installed,
-        })
-
-    return {
-        "success": True,
-        "result": {
-            "models": models,
-            "cache_dir": str(cache_dir),
-            "cache_exists": cache_exists,
-        },
-    }
-
-
-def download_model(profile: str, progress_callback: Optional[callable] = None) -> Dict[str, any]:
-    """Download a model by profile name.
-
-    Args:
-        profile: Model profile name (fast, code, multilingual, balanced)
-        progress_callback: Optional callback function to report progress
-
-    Returns:
-        Result dictionary with success status
-    """
-    if not FASTEMBED_AVAILABLE:
-        return {
-            "success": False,
-            "error": "fastembed not installed. Install with: pip install codexlens[semantic]",
-        }
-
-    if profile not in MODEL_PROFILES:
-        return {
-            "success": False,
-            "error": f"Unknown profile: {profile}. Available: {', '.join(MODEL_PROFILES.keys())}",
-        }
-
-    model_name = MODEL_PROFILES[profile]["model_name"]
-
-    try:
-        # Download model by instantiating TextEmbedding
-        # This will automatically download to cache if not present
-        if progress_callback:
-            progress_callback(f"Downloading {model_name}...")
-
-        embedder = TextEmbedding(model_name=model_name)
-
-        if progress_callback:
-            progress_callback(f"Model {model_name} downloaded successfully")
-
-        # Get cache info
-        cache_dir = get_cache_dir()
-        model_cache_path = cache_dir / f"models--{model_name.replace('/', '--')}"
-
-        cache_size = 0
-        if model_cache_path.exists():
-            total_size = sum(
-                f.stat().st_size
-                for f in model_cache_path.rglob("*")
-                if f.is_file()
-            )
-            cache_size = round(total_size / (1024 * 1024), 1)
-
-        return {
-            "success": True,
-            "result": {
-                "profile": profile,
-                "model_name": model_name,
-                "cache_size_mb": cache_size,
-                "cache_path": str(model_cache_path),
-            },
-        }
-
-    except Exception as e:
-        return {
-            "success": False,
-            "error": f"Failed to download model: {str(e)}",
-        }
-
-
-def delete_model(profile: str) -> Dict[str, any]:
-    """Delete a downloaded model from cache.
-
-    Args:
-        profile: Model profile name to delete
-
-    Returns:
-        Result dictionary with success status
-    """
-    if profile not in MODEL_PROFILES:
-        return {
-            "success": False,
-            "error": f"Unknown profile: {profile}. Available: {', '.join(MODEL_PROFILES.keys())}",
-        }
-
-    model_name = MODEL_PROFILES[profile]["model_name"]
-    cache_dir = get_cache_dir()
-    model_cache_path = cache_dir / f"models--{model_name.replace('/', '--')}"
-
-    if not model_cache_path.exists():
-        return {
-            "success": False,
-            "error": f"Model {profile} ({model_name}) is not installed",
-        }
-
-    try:
-        # Calculate size before deletion
-        total_size = sum(
-            f.stat().st_size
-            for f in model_cache_path.rglob("*")
-            if f.is_file()
-        )
-        size_mb = round(total_size / (1024 * 1024), 1)
-
-        # Delete model directory
-        shutil.rmtree(model_cache_path)
-
-        return {
-            "success": True,
-            "result": {
-                "profile": profile,
-                "model_name": model_name,
-                "deleted_size_mb": size_mb,
-                "cache_path": str(model_cache_path),
-            },
-        }
-
-    except Exception as e:
-        return {
-            "success": False,
-            "error": f"Failed to delete model: {str(e)}",
-        }
-
-
-def get_model_info(profile: str) -> Dict[str, any]:
-    """Get detailed information about a model profile.
-
-    Args:
-        profile: Model profile name
-
-    Returns:
-        Result dictionary with model information
-    """
-    if profile not in MODEL_PROFILES:
-        return {
-            "success": False,
-            "error": f"Unknown profile: {profile}. Available: {', '.join(MODEL_PROFILES.keys())}",
-        }
-
-    info = MODEL_PROFILES[profile]
-    model_name = info["model_name"]
-
-    # Check installation status
-    cache_dir = get_cache_dir()
-    model_cache_path = cache_dir / f"models--{model_name.replace('/', '--')}"
-    installed = model_cache_path.exists()
-
-    cache_size_mb = None
-    if installed:
-        total_size = sum(
-            f.stat().st_size
-            for f in model_cache_path.rglob("*")
-            if f.is_file()
-        )
-        cache_size_mb = round(total_size / (1024 * 1024), 1)
-
-    return {
-        "success": True,
-        "result": {
-            "profile": profile,
-            "model_name": model_name,
-            "dimensions": info["dimensions"],
-            "estimated_size_mb": info["size_mb"],
-            "actual_size_mb": cache_size_mb,
-            "description": info["description"],
-            "use_case": info["use_case"],
-            "installed": installed,
-            "cache_path": str(model_cache_path) if installed else None,
-        },
-    }

package/codex-lens/src/codexlens/cli/output.py

@@ -1,124 +0,0 @@
-"""Rich and JSON output helpers for CodexLens CLI."""
-
-from __future__ import annotations
-
-import json
-import sys
-from dataclasses import asdict, is_dataclass
-from pathlib import Path
-from typing import Any, Iterable, Mapping, Sequence
-
-from rich.console import Console
-from rich.table import Table
-from rich.text import Text
-
-from codexlens.entities import SearchResult, Symbol
-
-# Force UTF-8 encoding for Windows console to properly display Chinese text
-# Use force_terminal=True and legacy_windows=False to avoid GBK encoding issues
-console = Console(force_terminal=True, legacy_windows=False)
-
-
-def _to_jsonable(value: Any) -> Any:
-    if value is None:
-        return None
-    if hasattr(value, "model_dump"):
-        return value.model_dump()
-    if is_dataclass(value):
-        return asdict(value)
-    if isinstance(value, Path):
-        return str(value)
-    if isinstance(value, Mapping):
-        return {k: _to_jsonable(v) for k, v in value.items()}
-    if isinstance(value, (list, tuple, set)):
-        return [_to_jsonable(v) for v in value]
-    return value
-
-
-def print_json(*, success: bool, result: Any = None, error: str | None = None) -> None:
-    payload: dict[str, Any] = {"success": success}
-    if success:
-        payload["result"] = _to_jsonable(result)
-    else:
-        payload["error"] = error or "Unknown error"
-    console.print_json(json.dumps(payload, ensure_ascii=False))
-
-
-def render_search_results(
-    results: Sequence[SearchResult], *, title: str = "Search Results", verbose: bool = False
-) -> None:
-    """Render search results with optional source tags in verbose mode.
-
-    Args:
-        results: Search results to display
-        title: Table title
-        verbose: If True, show search source tags ([E], [F], [V]) and fusion scores
-    """
-    table = Table(title=title, show_lines=False)
-
-    if verbose:
-        # Verbose mode: show source tags
-        table.add_column("Source", style="dim", width=6, justify="center")
-
-    table.add_column("Path", style="cyan", no_wrap=True)
-    table.add_column("Score", style="magenta", justify="right")
-    table.add_column("Excerpt", style="white")
-
-    for res in results:
-        excerpt = res.excerpt or ""
-        score_str = f"{res.score:.3f}"
-
-        if verbose:
-            # Extract search source tag if available
-            source = getattr(res, "search_source", None)
-            source_tag = ""
-            if source == "exact":
-                source_tag = "[E]"
-            elif source == "fuzzy":
-                source_tag = "[F]"
-            elif source == "vector":
-                source_tag = "[V]"
-            elif source == "fusion":
-                source_tag = "[RRF]"
-            table.add_row(source_tag, res.path, score_str, excerpt)
-        else:
-            table.add_row(res.path, score_str, excerpt)
-
-    console.print(table)
-
-
-def render_symbols(symbols: Sequence[Symbol], *, title: str = "Symbols") -> None:
-    table = Table(title=title)
-    table.add_column("Name", style="green")
-    table.add_column("Kind", style="yellow")
-    table.add_column("Range", style="white", justify="right")
-
-    for sym in symbols:
-        start, end = sym.range
-        table.add_row(sym.name, sym.kind, f"{start}-{end}")
-
-    console.print(table)
-
-
-def render_status(stats: Mapping[str, Any]) -> None:
-    table = Table(title="Index Status")
-    table.add_column("Metric", style="cyan")
-    table.add_column("Value", style="white")
-
-    for key, value in stats.items():
-        if isinstance(value, Mapping):
-            value_text = ", ".join(f"{k}:{v}" for k, v in value.items())
-        elif isinstance(value, (list, tuple)):
-            value_text = ", ".join(str(v) for v in value)
-        else:
-            value_text = str(value)
-        table.add_row(str(key), value_text)
-
-    console.print(table)
-
-
-def render_file_inspect(path: str, language: str, symbols: Iterable[Symbol]) -> None:
-    header = Text.assemble(("File: ", "bold"), (path, "cyan"), ("  Language: ", "bold"), (language, "green"))
-    console.print(header)
-    render_symbols(list(symbols), title="Discovered Symbols")
-

package/codex-lens/src/codexlens/config.py

@@ -1,201 +0,0 @@
-"""Configuration system for CodexLens."""
-
-from __future__ import annotations
-
-import os
-from dataclasses import dataclass, field
-from functools import cached_property
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-from .errors import ConfigError
-
-
-# Workspace-local directory name
-WORKSPACE_DIR_NAME = ".codexlens"
-
-
-def _default_global_dir() -> Path:
-    """Get global CodexLens data directory."""
-    env_override = os.getenv("CODEXLENS_DATA_DIR")
-    if env_override:
-        return Path(env_override).expanduser().resolve()
-    return (Path.home() / ".codexlens").resolve()
-
-
-def find_workspace_root(start_path: Path) -> Optional[Path]:
-    """Find the workspace root by looking for .codexlens directory.
-
-    Searches from start_path upward to find an existing .codexlens directory.
-    Returns None if not found.
-    """
-    current = start_path.resolve()
-
-    # Search up to filesystem root
-    while current != current.parent:
-        workspace_dir = current / WORKSPACE_DIR_NAME
-        if workspace_dir.is_dir():
-            return current
-        current = current.parent
-
-    # Check root as well
-    workspace_dir = current / WORKSPACE_DIR_NAME
-    if workspace_dir.is_dir():
-        return current
-
-    return None
-
-
-@dataclass
-class Config:
-    """Runtime configuration for CodexLens.
-
-    - data_dir: Base directory for all persistent CodexLens data.
-    - venv_path: Optional virtualenv used for language tooling.
-    - supported_languages: Language IDs and their associated file extensions.
-    - parsing_rules: Per-language parsing and chunking hints.
-    """
-
-    data_dir: Path = field(default_factory=_default_global_dir)
-    venv_path: Path = field(default_factory=lambda: _default_global_dir() / "venv")
-    supported_languages: Dict[str, Dict[str, Any]] = field(
-        default_factory=lambda: {
-            "python": {"extensions": [".py"], "tree_sitter_language": "python"},
-            "javascript": {"extensions": [".js", ".jsx"], "tree_sitter_language": "javascript"},
-            "typescript": {"extensions": [".ts", ".tsx"], "tree_sitter_language": "typescript"},
-            "java": {"extensions": [".java"], "tree_sitter_language": "java"},
-            "go": {"extensions": [".go"], "tree_sitter_language": "go"},
-            "zig": {"extensions": [".zig"], "tree_sitter_language": "zig"},
-            "objective-c": {"extensions": [".m", ".mm"], "tree_sitter_language": "objc"},
-            "markdown": {"extensions": [".md", ".mdx"], "tree_sitter_language": None},
-            "text": {"extensions": [".txt"], "tree_sitter_language": None},
-        }
-    )
-    parsing_rules: Dict[str, Dict[str, Any]] = field(
-        default_factory=lambda: {
-            "default": {
-                "max_chunk_chars": 4000,
-                "max_chunk_lines": 200,
-                "overlap_lines": 20,
-            }
-        }
-    )
-
-    llm_enabled: bool = False
-    llm_tool: str = "gemini"
-    llm_timeout_ms: int = 300000
-    llm_batch_size: int = 5
-
-    # Hybrid chunker configuration
-    hybrid_max_chunk_size: int = 2000  # Max characters per chunk before LLM refinement
-    hybrid_llm_refinement: bool = False  # Enable LLM-based semantic boundary refinement
-    def __post_init__(self) -> None:
-        try:
-            self.data_dir = self.data_dir.expanduser().resolve()
-            self.venv_path = self.venv_path.expanduser().resolve()
-            self.data_dir.mkdir(parents=True, exist_ok=True)
-        except Exception as exc:
-            raise ConfigError(f"Failed to initialize data_dir at {self.data_dir}: {exc}") from exc
-
-    @cached_property
-    def cache_dir(self) -> Path:
-        """Directory for transient caches."""
-        return self.data_dir / "cache"
-
-    @cached_property
-    def index_dir(self) -> Path:
-        """Directory where index artifacts are stored."""
-        return self.data_dir / "index"
-
-    @cached_property
-    def db_path(self) -> Path:
-        """Default SQLite index path."""
-        return self.index_dir / "codexlens.db"
-
-    def ensure_runtime_dirs(self) -> None:
-        """Create standard runtime directories if missing."""
-        for directory in (self.cache_dir, self.index_dir):
-            try:
-                directory.mkdir(parents=True, exist_ok=True)
-            except Exception as exc:
-                raise ConfigError(f"Failed to create directory {directory}: {exc}") from exc
-
-    def language_for_path(self, path: str | Path) -> str | None:
-        """Infer a supported language ID from a file path."""
-        extension = Path(path).suffix.lower()
-        for language_id, spec in self.supported_languages.items():
-            extensions: List[str] = spec.get("extensions", [])
-            if extension in extensions:
-                return language_id
-        return None
-
-    def rules_for_language(self, language_id: str) -> Dict[str, Any]:
-        """Get parsing rules for a specific language, falling back to defaults."""
-        return {**self.parsing_rules.get("default", {}), **self.parsing_rules.get(language_id, {})}
-
-
-@dataclass
-class WorkspaceConfig:
-    """Workspace-local configuration for CodexLens.
-
-    Stores index data in project/.codexlens/ directory.
-    """
-
-    workspace_root: Path
-
-    def __post_init__(self) -> None:
-        self.workspace_root = Path(self.workspace_root).resolve()
-
-    @property
-    def codexlens_dir(self) -> Path:
-        """The .codexlens directory in workspace root."""
-        return self.workspace_root / WORKSPACE_DIR_NAME
-
-    @property
-    def db_path(self) -> Path:
-        """SQLite index path for this workspace."""
-        return self.codexlens_dir / "index.db"
-
-    @property
-    def cache_dir(self) -> Path:
-        """Cache directory for this workspace."""
-        return self.codexlens_dir / "cache"
-
-    def initialize(self) -> None:
-        """Create the .codexlens directory structure."""
-        try:
-            self.codexlens_dir.mkdir(parents=True, exist_ok=True)
-            self.cache_dir.mkdir(parents=True, exist_ok=True)
-
-            # Create .gitignore to exclude cache but keep index
-            gitignore_path = self.codexlens_dir / ".gitignore"
-            if not gitignore_path.exists():
-                gitignore_path.write_text(
-                    "# CodexLens workspace data\n"
-                    "cache/\n"
-                    "*.log\n"
-                )
-        except Exception as exc:
-            raise ConfigError(f"Failed to initialize workspace at {self.codexlens_dir}: {exc}") from exc
-
-    def exists(self) -> bool:
-        """Check if workspace is already initialized."""
-        return self.codexlens_dir.is_dir() and self.db_path.exists()
-
-    @classmethod
-    def from_path(cls, path: Path) -> Optional["WorkspaceConfig"]:
-        """Create WorkspaceConfig from a path by finding workspace root.
-
-        Returns None if no workspace found.
-        """
-        root = find_workspace_root(path)
-        if root is None:
-            return None
-        return cls(workspace_root=root)
-
-    @classmethod
-    def create_at(cls, path: Path) -> "WorkspaceConfig":
-        """Create a new workspace at the given path."""
-        config = cls(workspace_root=path)
-        config.initialize()
-        return config