ragrep 0.2.1__tar.gz → 0.2.2__tar.gz

{ragrep-0.2.1/src/ragrep.egg-info → ragrep-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragrep
-Version: 0.2.1
+Version: 0.2.2
 Summary: Local semantic code recall with mxbai embeddings and SQLite
 Author-email: RAGrep Team <ragrep@example.com>
 License-Expression: MIT

{ragrep-0.2.1 → ragrep-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ragrep"
-version = "0.2.1"
+version = "0.2.2"
 description = "Local semantic code recall with mxbai embeddings and SQLite"
 readme = "README.md"
 requires-python = ">=3.9"

{ragrep-0.2.1 → ragrep-0.2.2}/src/ragrep/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 __author__ = "RAGrep Team"
 
 

{ragrep-0.2.1 → ragrep-0.2.2}/src/ragrep/cli.py

@@ -117,15 +117,42 @@ def _run_gpu_info(args: argparse.Namespace) -> int:
     return 0
 
 
-def _print_new_file_paths(index_result: dict) -> None:
-    new_files = index_result.get("new_files") or []
-    if not new_files:
+def _print_file_paths(title: str, paths: list[str]) -> None:
+    if not paths:
         return
-    print("New files indexed:")
-    for path in new_files:
+    print(f"{title}:")
+    for path in paths:
         print(path)
 
 
+def _print_index_status(index_result: dict) -> None:
+    root = index_result.get("root") or index_result.get("indexed_root") or "."
+    new_files = index_result.get("new_files") or []
+    updated_files = index_result.get("updated_files") or []
+    removed_files = index_result.get("removed_files") or []
+
+    if index_result.get("indexed"):
+        print(
+            f"Index updated for {root}: "
+            f"{len(new_files)} added, {len(updated_files)} modified, {len(removed_files)} removed."
+        )
+        _print_file_paths("Added files", new_files)
+        _print_file_paths("Modified files", updated_files)
+        _print_file_paths("Removed files", removed_files)
+        print(
+            f"Indexed {index_result['indexed_files']} changed files "
+            f"({index_result['chunks_indexed']} chunks updated, {index_result['chunks']} total): "
+            f"{index_result['reason']}"
+        )
+        return
+
+    print(
+        f"Index is already up to date for {root} "
+        f"({index_result['files']} files, {index_result['chunks']} chunks): "
+        f"{index_result['reason']}"
+    )
+
+
 def _run_recall(args: argparse.Namespace) -> int:
     setup_logging(args.verbose)
     query = " ".join(args.query).strip()
@@ -150,13 +177,8 @@ def _run_recall(args: argparse.Namespace) -> int:
         return 0
 
     index_info = result.get("auto_index")
-    if index_info and index_info.get("indexed"):
-        _print_new_file_paths(index_info)
-        print(
-            f"Indexed {index_info['indexed_files']} changed files "
-            f"({index_info['chunks_indexed']} chunks updated, {index_info['chunks']} total): "
-            f"{index_info['reason']}"
-        )
+    if index_info:
+        _print_index_status(index_info)
 
     matches = result.get("matches", [])
     print(f"Results: {len(matches)}")
@@ -185,14 +207,7 @@ def _run_index(args: argparse.Namespace) -> int:
         print(json.dumps(result, indent=2))
         return 0
 
-    if result["indexed"]:
-        _print_new_file_paths(result)
-        print(
-            f"Indexed {result['indexed_files']} changed files "
-            f"({result['chunks_indexed']} chunks updated, {result['chunks']} total)"
-        )
-    else:
-        print(f"Index unchanged: {result['reason']}")
+    _print_index_status(result)
 
     return 0
 

{ragrep-0.2.1 → ragrep-0.2.2}/src/ragrep/core/document_processor.py

@@ -8,26 +8,39 @@ from typing import Any, Dict, Iterable, List
 
 
 _DEFAULT_EXTENSIONS = {
+    ".avsc",
     ".c",
     ".cc",
     ".cpp",
     ".css",
+    ".gql",
     ".go",
+    ".graphql",
+    ".graphqls",
     ".h",
     ".hpp",
     ".html",
     ".java",
     ".js",
     ".json",
+    ".markdown",
     ".md",
+    ".mdown",
+    ".mdx",
+    ".mkd",
+    ".mkdn",
     ".py",
     ".rb",
+    ".raml",
     ".rs",
     ".sql",
     ".toml",
     ".ts",
     ".txt",
+    ".proto",
+    ".wsdl",
     ".xml",
+    ".xsd",
     ".yaml",
     ".yml",
 }

{ragrep-0.2.1 → ragrep-0.2.2}/src/ragrep/retrieval/embeddings.py

@@ -115,6 +115,29 @@ def default_model_dir() -> Path:
     return base / "models"
 
 
+def _has_local_model_snapshot(model: str, model_dir: Path) -> bool:
+    """Return whether the requested model already exists in the local cache."""
+    model_path = Path(model).expanduser()
+    if model_path.exists():
+        return True
+
+    try:
+        from huggingface_hub import _CACHED_NO_EXIST, try_to_load_from_cache
+    except Exception:
+        return False
+
+    for filename in ("modules.json", "config.json", "tokenizer_config.json"):
+        cached = try_to_load_from_cache(
+            repo_id=model,
+            filename=filename,
+            cache_dir=str(model_dir),
+        )
+        if cached is not None and cached != _CACHED_NO_EXIST:
+            return True
+
+    return False
+
+
 class LocalEmbedder:
     """Generate embeddings in-process using sentence-transformers."""
 
@@ -139,17 +162,46 @@ class LocalEmbedder:
                 "Install with: pip install sentence-transformers"
             ) from exc
 
+        prefer_local_only = _has_local_model_snapshot(self.resolved_model, self.model_dir)
+
         try:
-            self._model = SentenceTransformer(
-                self.resolved_model,
-                cache_folder=str(self.model_dir),
-                device=self.device,
+            self._model = self._load_model(
+                SentenceTransformer,
+                local_files_only=prefer_local_only,
             )
         except Exception as exc:  # pragma: no cover - model download/load depends on environment
-            raise EmbeddingError(
-                f"Failed to load embedding model '{self.resolved_model}'. "
-                f"Model directory: {self.model_dir}."
-            ) from exc
+            if prefer_local_only:
+                try:
+                    self._model = self._load_model(
+                        SentenceTransformer,
+                        local_files_only=False,
+                    )
+                except Exception as retry_exc:
+                    raise EmbeddingError(
+                        f"Failed to load embedding model '{self.resolved_model}'. "
+                        f"Model directory: {self.model_dir}."
+                    ) from retry_exc
+            else:
+                raise EmbeddingError(
+                    f"Failed to load embedding model '{self.resolved_model}'. "
+                    f"Model directory: {self.model_dir}."
+                ) from exc
+
+    def _load_model(self, sentence_transformer_cls: Any, *, local_files_only: bool) -> Any:
+        kwargs: Dict[str, Any] = {
+            "cache_folder": str(self.model_dir),
+            "device": self.device,
+            "local_files_only": local_files_only,
+        }
+
+        try:
+            return sentence_transformer_cls(self.resolved_model, **kwargs)
+        except TypeError as exc:
+            if "local_files_only" not in str(exc):
+                raise
+
+        kwargs.pop("local_files_only", None)
+        return sentence_transformer_cls(self.resolved_model, **kwargs)
 
     def embed_texts(self, texts: Iterable[str], batch_size: int = 32) -> List[List[float]]:
         items = list(texts)

{ragrep-0.2.1 → ragrep-0.2.2/src/ragrep.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragrep
-Version: 0.2.1
+Version: 0.2.2
 Summary: Local semantic code recall with mxbai embeddings and SQLite
 Author-email: RAGrep Team <ragrep@example.com>
 License-Expression: MIT

ragrep-0.2.2/tests/test_cli.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import json
+import tempfile
+import unittest
+from contextlib import redirect_stdout
+from io import StringIO
+from pathlib import Path
+from unittest.mock import patch
+
+from ragrep.cli import main
+
+
+class CLITests(unittest.TestCase):
+    def test_stats_flag_alias(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            db_path = Path(temp_dir) / ".ragrep.db"
+
+            output = StringIO()
+            with redirect_stdout(output):
+                exit_code = main(["--stats", "--json", "--db-path", str(db_path)])
+
+            self.assertEqual(exit_code, 0)
+            payload = json.loads(output.getvalue())
+            self.assertEqual(payload["backend"], "sqlite")
+            self.assertEqual(payload["total_chunks"], 0)
+
+    def test_check_gpu_flag_alias(self):
+        output = StringIO()
+        with redirect_stdout(output):
+            exit_code = main(["--check-gpu", "--json"])
+
+        self.assertEqual(exit_code, 0)
+        payload = json.loads(output.getvalue())
+        self.assertIn("resolved_device", payload)
+        self.assertIn("torch_available", payload)
+
+    def test_index_prints_added_modified_and_removed_file_paths(self):
+        class DummyRAG:
+            def __init__(self, *args, **kwargs):
+                pass
+
+            def __enter__(self):
+                return self
+
+            def __exit__(self, exc_type, exc, tb):
+                return None
+
+            def index(self, path=".", force=False):
+                return {
+                    "indexed": True,
+                    "reason": "new files detected, updated files detected, files removed",
+                    "root": "/tmp/work",
+                    "files": 3,
+                    "chunks": 10,
+                    "chunks_indexed": 4,
+                    "indexed_files": 2,
+                    "new_files": ["src/new_file.py"],
+                    "updated_files": ["src/changed_file.py"],
+                    "removed_files": ["src/removed_file.py"],
+                    "full_rebuild": False,
+                }
+
+        output = StringIO()
+        with patch("ragrep.cli.RAGrep", DummyRAG):
+            with redirect_stdout(output):
+                exit_code = main(["index", "."])
+
+        self.assertEqual(exit_code, 0)
+        text = output.getvalue()
+        self.assertIn("Index updated for /tmp/work: 1 added, 1 modified, 1 removed.", text)
+        self.assertIn("Added files:", text)
+        self.assertIn("src/new_file.py", text)
+        self.assertIn("Modified files:", text)
+        self.assertIn("src/changed_file.py", text)
+        self.assertIn("Removed files:", text)
+        self.assertIn("src/removed_file.py", text)
+        self.assertIn(
+            "Indexed 2 changed files (4 chunks updated, 10 total): "
+            "new files detected, updated files detected, files removed",
+            text,
+        )
+
+    def test_recall_prints_up_to_date_status_before_results(self):
+        class DummyRAG:
+            def __init__(self, *args, **kwargs):
+                pass
+
+            def __enter__(self):
+                return self
+
+            def __exit__(self, exc_type, exc, tb):
+                return None
+
+            def recall(self, query, limit=20, path=None, auto_index=True):
+                return {
+                    "query": query,
+                    "count": 1,
+                    "matches": [
+                        {
+                            "score": 0.9,
+                            "text": "# Schema",
+                            "metadata": {"source": "docs/schema.md"},
+                        }
+                    ],
+                    "auto_index": {
+                        "indexed": False,
+                        "reason": "index is current",
+                        "root": "/tmp/work",
+                        "files": 2,
+                        "chunks": 8,
+                        "chunks_indexed": 0,
+                        "indexed_files": 0,
+                        "new_files": [],
+                        "updated_files": [],
+                        "removed_files": [],
+                        "full_rebuild": False,
+                    },
+                }
+
+        output = StringIO()
+        with patch("ragrep.cli.RAGrep", DummyRAG):
+            with redirect_stdout(output):
+                exit_code = main(["schema"])
+
+        self.assertEqual(exit_code, 0)
+        text = output.getvalue()
+        self.assertIn(
+            "Index is already up to date for /tmp/work (2 files, 8 chunks): index is current",
+            text,
+        )
+        self.assertIn("Results: 1", text)
+        self.assertLess(
+            text.index("Index is already up to date for /tmp/work"),
+            text.index("Results: 1"),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

ragrep-0.2.2/tests/test_embeddings.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from types import ModuleType
+from unittest.mock import patch
+
+from ragrep.retrieval.embeddings import (
+    LocalEmbedder,
+    default_model_dir,
+    get_runtime_device_info,
+    resolve_embedding_model,
+    resolve_runtime_device,
+)
+
+
+class EmbeddingConfigTests(unittest.TestCase):
+    def test_model_alias_resolution(self):
+        self.assertEqual(
+            resolve_embedding_model("mxbai-embed-large"),
+            "mixedbread-ai/mxbai-embed-large-v1",
+        )
+        self.assertEqual(resolve_embedding_model("custom/model"), "custom/model")
+
+    def test_model_dir_env_override(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with patch.dict(os.environ, {"RAGREP_MODEL_DIR": temp_dir}, clear=False):
+                self.assertEqual(default_model_dir(), Path(temp_dir).resolve())
+
+    def test_device_auto_without_torch(self):
+        with patch.dict(sys.modules, {"torch": None}):
+            self.assertEqual(resolve_runtime_device("auto"), "cpu")
+
+    def test_device_auto_prefers_cuda(self):
+        fake_torch = SimpleNamespace(
+            cuda=SimpleNamespace(is_available=lambda: True),
+            backends=SimpleNamespace(mps=SimpleNamespace(is_available=lambda: False)),
+        )
+        with patch.dict(sys.modules, {"torch": fake_torch}):
+            self.assertEqual(resolve_runtime_device("auto"), "cuda")
+
+    def test_device_auto_uses_mps_when_cuda_missing(self):
+        fake_torch = SimpleNamespace(
+            cuda=SimpleNamespace(is_available=lambda: False),
+            backends=SimpleNamespace(mps=SimpleNamespace(is_available=lambda: True)),
+        )
+        with patch.dict(sys.modules, {"torch": fake_torch}):
+            self.assertEqual(resolve_runtime_device("auto"), "mps")
+
+    def test_explicit_device_is_respected(self):
+        self.assertEqual(resolve_runtime_device("cpu"), "cpu")
+        self.assertEqual(resolve_runtime_device("cuda:0"), "cuda:0")
+
+    def test_runtime_device_info_without_torch(self):
+        with patch.dict(sys.modules, {"torch": None}):
+            info = get_runtime_device_info("auto")
+            self.assertFalse(info["torch_available"])
+            self.assertEqual(info["resolved_device"], "cpu")
+
+    def test_runtime_device_info_with_cuda_inventory(self):
+        fake_torch = SimpleNamespace(
+            cuda=SimpleNamespace(
+                is_available=lambda: True,
+                device_count=lambda: 2,
+                get_device_name=lambda i: f"GPU-{i}",
+            ),
+            backends=SimpleNamespace(mps=SimpleNamespace(is_available=lambda: False)),
+        )
+        with patch.dict(sys.modules, {"torch": fake_torch}):
+            info = get_runtime_device_info("auto")
+            self.assertTrue(info["torch_available"])
+            self.assertTrue(info["cuda_available"])
+            self.assertEqual(info["cuda_device_count"], 2)
+            self.assertEqual(info["cuda_devices"], ["GPU-0", "GPU-1"])
+
+    def test_local_embedder_uses_local_files_only_when_model_is_cached(self):
+        calls = []
+        sentence_transformers = ModuleType("sentence_transformers")
+        huggingface_hub = ModuleType("huggingface_hub")
+        cached_marker = object()
+
+        class FakeSentenceTransformer:
+            def __init__(self, model_name, **kwargs):
+                calls.append({"model_name": model_name, **kwargs})
+
+        def try_to_load_from_cache(*, repo_id, filename, cache_dir):
+            if repo_id == "mixedbread-ai/mxbai-embed-large-v1" and filename == "modules.json":
+                return str(Path(cache_dir) / "models--cached" / "modules.json")
+            return cached_marker
+
+        sentence_transformers.SentenceTransformer = FakeSentenceTransformer
+        huggingface_hub.try_to_load_from_cache = try_to_load_from_cache
+        huggingface_hub._CACHED_NO_EXIST = cached_marker
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with patch.dict(
+                sys.modules,
+                {
+                    "sentence_transformers": sentence_transformers,
+                    "huggingface_hub": huggingface_hub,
+                },
+            ):
+                LocalEmbedder(model_dir=temp_dir, device="cpu")
+
+        self.assertEqual(len(calls), 1)
+        self.assertTrue(calls[0]["local_files_only"])
+
+    def test_local_embedder_allows_download_when_cache_is_missing(self):
+        calls = []
+        sentence_transformers = ModuleType("sentence_transformers")
+        huggingface_hub = ModuleType("huggingface_hub")
+        cached_marker = object()
+
+        class FakeSentenceTransformer:
+            def __init__(self, model_name, **kwargs):
+                calls.append({"model_name": model_name, **kwargs})
+
+        def try_to_load_from_cache(*, repo_id, filename, cache_dir):
+            return cached_marker
+
+        sentence_transformers.SentenceTransformer = FakeSentenceTransformer
+        huggingface_hub.try_to_load_from_cache = try_to_load_from_cache
+        huggingface_hub._CACHED_NO_EXIST = cached_marker
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with patch.dict(
+                sys.modules,
+                {
+                    "sentence_transformers": sentence_transformers,
+                    "huggingface_hub": huggingface_hub,
+                },
+            ):
+                LocalEmbedder(model_dir=temp_dir, device="cpu")
+
+        self.assertEqual(len(calls), 1)
+        self.assertFalse(calls[0]["local_files_only"])
+
+    def test_local_embedder_retries_without_local_only_when_cached_load_fails(self):
+        calls = []
+        sentence_transformers = ModuleType("sentence_transformers")
+        huggingface_hub = ModuleType("huggingface_hub")
+        cached_marker = object()
+
+        class FakeSentenceTransformer:
+            def __init__(self, model_name, **kwargs):
+                calls.append({"model_name": model_name, **kwargs})
+                if kwargs.get("local_files_only"):
+                    raise OSError("cache incomplete")
+
+        def try_to_load_from_cache(*, repo_id, filename, cache_dir):
+            if filename == "modules.json":
+                return str(Path(cache_dir) / "models--cached" / "modules.json")
+            return cached_marker
+
+        sentence_transformers.SentenceTransformer = FakeSentenceTransformer
+        huggingface_hub.try_to_load_from_cache = try_to_load_from_cache
+        huggingface_hub._CACHED_NO_EXIST = cached_marker
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with patch.dict(
+                sys.modules,
+                {
+                    "sentence_transformers": sentence_transformers,
+                    "huggingface_hub": huggingface_hub,
+                },
+            ):
+                LocalEmbedder(model_dir=temp_dir, device="cpu")
+
+        self.assertEqual(len(calls), 2)
+        self.assertTrue(calls[0]["local_files_only"])
+        self.assertFalse(calls[1]["local_files_only"])
+
+
+if __name__ == "__main__":
+    unittest.main()

{ragrep-0.2.1 → ragrep-0.2.2}/tests/test_ragrep.py

@@ -20,6 +20,10 @@ class FakeEmbedder:
         "payment",
         "cache",
         "error",
+        "schema",
+        "user",
+        "message",
+        "type",
     ]
 
     def embed_texts(self, texts, batch_size: int = 32):
@@ -151,6 +155,56 @@ class RAGrepTests(unittest.TestCase):
         finally:
             rag.close()
 
+    def test_index_and_recall_schema_files(self):
+        schema_root = self.root / "schemas"
+        schema_root.mkdir(parents=True, exist_ok=True)
+        (schema_root / "user.graphql").write_text(
+            "type User {\n  id: ID!\n  email: String!\n}\n",
+            encoding="utf-8",
+        )
+        (schema_root / "user.proto").write_text(
+            "syntax = \"proto3\";\nmessage User {\n  string id = 1;\n}\n",
+            encoding="utf-8",
+        )
+
+        rag = RAGrep(db_path=str(self.db_path), embedder=FakeEmbedder())
+        try:
+            index_result = rag.index(str(schema_root))
+            self.assertTrue(index_result["indexed"])
+            self.assertEqual(index_result["files"], 2)
+
+            recall_result = rag.recall("schema user", limit=5, auto_index=False)
+            self.assertEqual(recall_result["count"], 2)
+            sources = {match["metadata"]["source"] for match in recall_result["matches"]}
+            self.assertEqual(sources, {"user.graphql", "user.proto"})
+        finally:
+            rag.close()
+
+    def test_index_and_recall_markdown_variants(self):
+        docs_root = self.root / "docs"
+        docs_root.mkdir(parents=True, exist_ok=True)
+        (docs_root / "schema.mdx").write_text(
+            "# Schema\n\nUser field documentation.\n",
+            encoding="utf-8",
+        )
+        (docs_root / "database.markdown").write_text(
+            "# Database\n\nSchema for the user table.\n",
+            encoding="utf-8",
+        )
+
+        rag = RAGrep(db_path=str(self.db_path), embedder=FakeEmbedder())
+        try:
+            index_result = rag.index(str(docs_root))
+            self.assertTrue(index_result["indexed"])
+            self.assertEqual(index_result["files"], 2)
+
+            recall_result = rag.recall("schema user", limit=5, auto_index=False)
+            self.assertEqual(recall_result["count"], 2)
+            sources = {match["metadata"]["source"] for match in recall_result["matches"]}
+            self.assertEqual(sources, {"schema.mdx", "database.markdown"})
+        finally:
+            rag.close()
+
     def test_stats(self):
         rag = RAGrep(db_path=str(self.db_path), embedder=FakeEmbedder())
         try:

ragrep-0.2.1/tests/test_cli.py

@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-import json
-import tempfile
-import unittest
-from contextlib import redirect_stdout
-from io import StringIO
-from pathlib import Path
-from unittest.mock import patch
-
-from ragrep.cli import main
-
-
-class CLITests(unittest.TestCase):
-    def test_stats_flag_alias(self):
-        with tempfile.TemporaryDirectory() as temp_dir:
-            db_path = Path(temp_dir) / ".ragrep.db"
-
-            output = StringIO()
-            with redirect_stdout(output):
-                exit_code = main(["--stats", "--json", "--db-path", str(db_path)])
-
-            self.assertEqual(exit_code, 0)
-            payload = json.loads(output.getvalue())
-            self.assertEqual(payload["backend"], "sqlite")
-            self.assertEqual(payload["total_chunks"], 0)
-
-    def test_check_gpu_flag_alias(self):
-        output = StringIO()
-        with redirect_stdout(output):
-            exit_code = main(["--check-gpu", "--json"])
-
-        self.assertEqual(exit_code, 0)
-        payload = json.loads(output.getvalue())
-        self.assertIn("resolved_device", payload)
-        self.assertIn("torch_available", payload)
-
-    def test_index_prints_new_file_paths(self):
-        class DummyRAG:
-            def __init__(self, *args, **kwargs):
-                pass
-
-            def __enter__(self):
-                return self
-
-            def __exit__(self, exc_type, exc, tb):
-                return None
-
-            def index(self, path=".", force=False):
-                return {
-                    "indexed": True,
-                    "reason": "new files detected",
-                    "root": "/tmp/work",
-                    "files": 3,
-                    "chunks": 10,
-                    "chunks_indexed": 4,
-                    "indexed_files": 1,
-                    "new_files": ["src/new_file.py"],
-                    "updated_files": [],
-                    "removed_files": [],
-                    "full_rebuild": False,
-                }
-
-        output = StringIO()
-        with patch("ragrep.cli.RAGrep", DummyRAG):
-            with redirect_stdout(output):
-                exit_code = main(["index", "."])
-
-        self.assertEqual(exit_code, 0)
-        text = output.getvalue()
-        self.assertIn("New files indexed:", text)
-        self.assertIn("src/new_file.py", text)
-
-
-if __name__ == "__main__":
-    unittest.main()

ragrep-0.2.1/tests/test_embeddings.py

@@ -1,80 +0,0 @@
-from __future__ import annotations
-
-import os
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-from types import SimpleNamespace
-from unittest.mock import patch
-
-from ragrep.retrieval.embeddings import (
-    default_model_dir,
-    get_runtime_device_info,
-    resolve_embedding_model,
-    resolve_runtime_device,
-)
-
-
-class EmbeddingConfigTests(unittest.TestCase):
-    def test_model_alias_resolution(self):
-        self.assertEqual(
-            resolve_embedding_model("mxbai-embed-large"),
-            "mixedbread-ai/mxbai-embed-large-v1",
-        )
-        self.assertEqual(resolve_embedding_model("custom/model"), "custom/model")
-
-    def test_model_dir_env_override(self):
-        with tempfile.TemporaryDirectory() as temp_dir:
-            with patch.dict(os.environ, {"RAGREP_MODEL_DIR": temp_dir}, clear=False):
-                self.assertEqual(default_model_dir(), Path(temp_dir).resolve())
-
-    def test_device_auto_without_torch(self):
-        with patch.dict(sys.modules, {"torch": None}):
-            self.assertEqual(resolve_runtime_device("auto"), "cpu")
-
-    def test_device_auto_prefers_cuda(self):
-        fake_torch = SimpleNamespace(
-            cuda=SimpleNamespace(is_available=lambda: True),
-            backends=SimpleNamespace(mps=SimpleNamespace(is_available=lambda: False)),
-        )
-        with patch.dict(sys.modules, {"torch": fake_torch}):
-            self.assertEqual(resolve_runtime_device("auto"), "cuda")
-
-    def test_device_auto_uses_mps_when_cuda_missing(self):
-        fake_torch = SimpleNamespace(
-            cuda=SimpleNamespace(is_available=lambda: False),
-            backends=SimpleNamespace(mps=SimpleNamespace(is_available=lambda: True)),
-        )
-        with patch.dict(sys.modules, {"torch": fake_torch}):
-            self.assertEqual(resolve_runtime_device("auto"), "mps")
-
-    def test_explicit_device_is_respected(self):
-        self.assertEqual(resolve_runtime_device("cpu"), "cpu")
-        self.assertEqual(resolve_runtime_device("cuda:0"), "cuda:0")
-
-    def test_runtime_device_info_without_torch(self):
-        with patch.dict(sys.modules, {"torch": None}):
-            info = get_runtime_device_info("auto")
-            self.assertFalse(info["torch_available"])
-            self.assertEqual(info["resolved_device"], "cpu")
-
-    def test_runtime_device_info_with_cuda_inventory(self):
-        fake_torch = SimpleNamespace(
-            cuda=SimpleNamespace(
-                is_available=lambda: True,
-                device_count=lambda: 2,
-                get_device_name=lambda i: f"GPU-{i}",
-            ),
-            backends=SimpleNamespace(mps=SimpleNamespace(is_available=lambda: False)),
-        )
-        with patch.dict(sys.modules, {"torch": fake_torch}):
-            info = get_runtime_device_info("auto")
-            self.assertTrue(info["torch_available"])
-            self.assertTrue(info["cuda_available"])
-            self.assertEqual(info["cuda_device_count"], 2)
-            self.assertEqual(info["cuda_devices"], ["GPU-0", "GPU-1"])
-
-
-if __name__ == "__main__":
-    unittest.main()