agent-coderag 1.3.5__tar.gz → 1.4.0__tar.gz

{agent_coderag-1.3.5/agent_coderag.egg-info → agent_coderag-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-coderag
-Version: 1.3.5
+Version: 1.4.0
 Summary: Lightweight semantic code search and distillation utility for AI coding agents. It solves the API knowledge gap via real-time local signature extraction and intent analysis without PyTorch. Optimized for token efficiency, it compresses codebase context into compact semantic summaries stored in a local DuckDB vector similarity index.
 Author-email: Igor Boloban <naranor@gmail.com>
 License: MIT
@@ -110,7 +110,7 @@ agent-coderag setup
 agent-coderag config --url "http://localhost:11434" --provider "ollama" --model "qwen2.5-coder"
 
 # Using OpenAI-compatible API (e.g. Groq, OpenRouter, DeepSeek)
-agent-coderag config --url "https://api.deepseek.com" --key "your-api-key" --model "deepseek-chat"
+agent-coderag config --url "https://api.deepseek.com" --provider "openai" --key "your-api-key" --model "deepseek-chat"
 ```
 
 ### Offline Mode (No Provider)
@@ -163,17 +163,37 @@ agent-coderag api fmt
 
 ## Library Usage
 
+> **1.4.0 migration:** Storage lifetime and default DB resolution changed. Pin `agent-coderag<1.4` until you adapt (see [Database & lifetime](#database--lifetime)).
+
 ```python
-from code_rag import CodeRAG
+from pathlib import Path
+
+from code_rag import CodeRAG, default_db_path
 
 async def main():
-    async with CodeRAG(db="code_rag.db") as rag:
+    root = Path(".")
+    print(default_db_path(root))  # resolved path before first sync
+
+    # db=None (default): legacy code_rag.db in cwd/root, else root/.coderag.db
+    async with CodeRAG(root=root) as rag:
         await rag.setup()
         await rag.sync(index_all=True)
         hits = await rag.search("authentication middleware", limit=5)
+        # Opens the DB only when a provider needs it (e.g. Java JAR cache).
         report = await rag.api("pydantic", lang="python")
 ```
 
+### Database & lifetime
+
+- **Default path (`db=None`):** resolution order is (1) `./code_rag.db` if it exists, (2) else `{root}/code_rag.db` if it exists, (3) else `{root}/.coderag.db` (created on first `sync`/`rebuild`). Use `default_db_path(root)` to preview. New projects: prefer `.coderag.db` (step 3) or set `db=` explicitly.
+- **Explicit path:** `CodeRAG(db=...)` / `agent-coderag --db ...`. Path is a **file**, not a directory. Relative paths resolve against **process cwd**, not `root`.
+- **Sidecars:** DuckDB may write WAL sidecars (e.g. `.coderag.db.wal`) beside the index during writes; locks should not persist after an operation finishes.
+- **Connect timeout:** `connect_timeout_seconds=5` (CLI `--connect-timeout`) waits on file locks, then raises `StorageBusyError` (`ErrorCode.STORAGE_BUSY`). Pass `0` for a single attempt.
+- **Read-only search:** `search` (and `api` when storage is needed) opens read-only. A missing index file is an error — use `sync`/`rebuild` to create it. With `--json`, success is a hit array; errors are `{"status":"error","message":...}` (same shape as `sync`/`api` failures).
+- **Lifetime:** embedder/parser/distiller stay warm; DuckDB opens per operation and closes afterward. One `CodeRAG` instance serializes overlapping ops. `config()` with embedding flags / `--clear-embedding` closes the process embedder so the next op rebuilds it; distill-only `config` refreshes Distiller and keeps the embedder.
+- **`api()` without DB:** providers that do not need the index (e.g. Python) skip DuckDB entirely; Java uses a short read-only open for JAR cache lookup.
+- **Errors:** catch `CodeRAGError` and inspect `.code` — `STORAGE_BUSY`, `STORAGE_CORRUPT`, `EMBEDDING_MISMATCH` (`from code_rag import ErrorCode`).
+
 ---
 
 ## Supported Ecosystems (Discovery)

{agent_coderag-1.3.5 → agent_coderag-1.4.0}/README.md

@@ -64,7 +64,7 @@ agent-coderag setup
 agent-coderag config --url "http://localhost:11434" --provider "ollama" --model "qwen2.5-coder"
 
 # Using OpenAI-compatible API (e.g. Groq, OpenRouter, DeepSeek)
-agent-coderag config --url "https://api.deepseek.com" --key "your-api-key" --model "deepseek-chat"
+agent-coderag config --url "https://api.deepseek.com" --provider "openai" --key "your-api-key" --model "deepseek-chat"
 ```
 
 ### Offline Mode (No Provider)
@@ -117,17 +117,37 @@ agent-coderag api fmt
 
 ## Library Usage
 
+> **1.4.0 migration:** Storage lifetime and default DB resolution changed. Pin `agent-coderag<1.4` until you adapt (see [Database & lifetime](#database--lifetime)).
+
 ```python
-from code_rag import CodeRAG
+from pathlib import Path
+
+from code_rag import CodeRAG, default_db_path
 
 async def main():
-    async with CodeRAG(db="code_rag.db") as rag:
+    root = Path(".")
+    print(default_db_path(root))  # resolved path before first sync
+
+    # db=None (default): legacy code_rag.db in cwd/root, else root/.coderag.db
+    async with CodeRAG(root=root) as rag:
         await rag.setup()
         await rag.sync(index_all=True)
         hits = await rag.search("authentication middleware", limit=5)
+        # Opens the DB only when a provider needs it (e.g. Java JAR cache).
         report = await rag.api("pydantic", lang="python")
 ```
 
+### Database & lifetime
+
+- **Default path (`db=None`):** resolution order is (1) `./code_rag.db` if it exists, (2) else `{root}/code_rag.db` if it exists, (3) else `{root}/.coderag.db` (created on first `sync`/`rebuild`). Use `default_db_path(root)` to preview. New projects: prefer `.coderag.db` (step 3) or set `db=` explicitly.
+- **Explicit path:** `CodeRAG(db=...)` / `agent-coderag --db ...`. Path is a **file**, not a directory. Relative paths resolve against **process cwd**, not `root`.
+- **Sidecars:** DuckDB may write WAL sidecars (e.g. `.coderag.db.wal`) beside the index during writes; locks should not persist after an operation finishes.
+- **Connect timeout:** `connect_timeout_seconds=5` (CLI `--connect-timeout`) waits on file locks, then raises `StorageBusyError` (`ErrorCode.STORAGE_BUSY`). Pass `0` for a single attempt.
+- **Read-only search:** `search` (and `api` when storage is needed) opens read-only. A missing index file is an error — use `sync`/`rebuild` to create it. With `--json`, success is a hit array; errors are `{"status":"error","message":...}` (same shape as `sync`/`api` failures).
+- **Lifetime:** embedder/parser/distiller stay warm; DuckDB opens per operation and closes afterward. One `CodeRAG` instance serializes overlapping ops. `config()` with embedding flags / `--clear-embedding` closes the process embedder so the next op rebuilds it; distill-only `config` refreshes Distiller and keeps the embedder.
+- **`api()` without DB:** providers that do not need the index (e.g. Python) skip DuckDB entirely; Java uses a short read-only open for JAR cache lookup.
+- **Errors:** catch `CodeRAGError` and inspect `.code` — `STORAGE_BUSY`, `STORAGE_CORRUPT`, `EMBEDDING_MISMATCH` (`from code_rag import ErrorCode`).
+
 ---
 
 ## Supported Ecosystems (Discovery)

{agent_coderag-1.3.5 → agent_coderag-1.4.0/agent_coderag.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-coderag
-Version: 1.3.5
+Version: 1.4.0
 Summary: Lightweight semantic code search and distillation utility for AI coding agents. It solves the API knowledge gap via real-time local signature extraction and intent analysis without PyTorch. Optimized for token efficiency, it compresses codebase context into compact semantic summaries stored in a local DuckDB vector similarity index.
 Author-email: Igor Boloban <naranor@gmail.com>
 License: MIT
@@ -110,7 +110,7 @@ agent-coderag setup
 agent-coderag config --url "http://localhost:11434" --provider "ollama" --model "qwen2.5-coder"
 
 # Using OpenAI-compatible API (e.g. Groq, OpenRouter, DeepSeek)
-agent-coderag config --url "https://api.deepseek.com" --key "your-api-key" --model "deepseek-chat"
+agent-coderag config --url "https://api.deepseek.com" --provider "openai" --key "your-api-key" --model "deepseek-chat"
 ```
 
 ### Offline Mode (No Provider)
@@ -163,17 +163,37 @@ agent-coderag api fmt
 
 ## Library Usage
 
+> **1.4.0 migration:** Storage lifetime and default DB resolution changed. Pin `agent-coderag<1.4` until you adapt (see [Database & lifetime](#database--lifetime)).
+
 ```python
-from code_rag import CodeRAG
+from pathlib import Path
+
+from code_rag import CodeRAG, default_db_path
 
 async def main():
-    async with CodeRAG(db="code_rag.db") as rag:
+    root = Path(".")
+    print(default_db_path(root))  # resolved path before first sync
+
+    # db=None (default): legacy code_rag.db in cwd/root, else root/.coderag.db
+    async with CodeRAG(root=root) as rag:
         await rag.setup()
         await rag.sync(index_all=True)
         hits = await rag.search("authentication middleware", limit=5)
+        # Opens the DB only when a provider needs it (e.g. Java JAR cache).
         report = await rag.api("pydantic", lang="python")
 ```
 
+### Database & lifetime
+
+- **Default path (`db=None`):** resolution order is (1) `./code_rag.db` if it exists, (2) else `{root}/code_rag.db` if it exists, (3) else `{root}/.coderag.db` (created on first `sync`/`rebuild`). Use `default_db_path(root)` to preview. New projects: prefer `.coderag.db` (step 3) or set `db=` explicitly.
+- **Explicit path:** `CodeRAG(db=...)` / `agent-coderag --db ...`. Path is a **file**, not a directory. Relative paths resolve against **process cwd**, not `root`.
+- **Sidecars:** DuckDB may write WAL sidecars (e.g. `.coderag.db.wal`) beside the index during writes; locks should not persist after an operation finishes.
+- **Connect timeout:** `connect_timeout_seconds=5` (CLI `--connect-timeout`) waits on file locks, then raises `StorageBusyError` (`ErrorCode.STORAGE_BUSY`). Pass `0` for a single attempt.
+- **Read-only search:** `search` (and `api` when storage is needed) opens read-only. A missing index file is an error — use `sync`/`rebuild` to create it. With `--json`, success is a hit array; errors are `{"status":"error","message":...}` (same shape as `sync`/`api` failures).
+- **Lifetime:** embedder/parser/distiller stay warm; DuckDB opens per operation and closes afterward. One `CodeRAG` instance serializes overlapping ops. `config()` with embedding flags / `--clear-embedding` closes the process embedder so the next op rebuilds it; distill-only `config` refreshes Distiller and keeps the embedder.
+- **`api()` without DB:** providers that do not need the index (e.g. Python) skip DuckDB entirely; Java uses a short read-only open for JAR cache lookup.
+- **Errors:** catch `CodeRAGError` and inspect `.code` — `STORAGE_BUSY`, `STORAGE_CORRUPT`, `EMBEDDING_MISMATCH` (`from code_rag import ErrorCode`).
+
 ---
 
 ## Supported Ecosystems (Discovery)

{agent_coderag-1.3.5 → agent_coderag-1.4.0}/agent_coderag.egg-info/SOURCES.txt

@@ -9,14 +9,15 @@ agent_coderag.egg-info/entry_points.txt
 agent_coderag.egg-info/requires.txt
 agent_coderag.egg-info/top_level.txt
 code_rag/__init__.py
+code_rag/paths.py
 code_rag/api/__init__.py
 code_rag/api/client.py
 code_rag/api/models.py
 code_rag/core/__init__.py
 code_rag/core/constants.py
+code_rag/core/error_codes.py
 code_rag/core/exceptions.py
 code_rag/core/interfaces.py
-code_rag/core/manager.py
 code_rag/core/models.py
 code_rag/core/utils.py
 code_rag/discovery/__init__.py
@@ -44,14 +45,18 @@ code_rag/parsers/multi_parser.py
 code_rag/parsers/tree_sitter.py
 code_rag/services/__init__.py
 code_rag/services/config.py
+code_rag/services/dependencies.py
 code_rag/services/discovery_api.py
 code_rag/services/factory.py
+code_rag/services/indexing.py
 code_rag/services/search.py
 code_rag/services/setup.py
 code_rag/services/sync.py
 code_rag/storage/__init__.py
+code_rag/storage/db_connection.py
 code_rag/storage/duckdb_impl.py
 tests/test_api_client.py
+tests/test_api_lazy_db.py
 tests/test_api_models.py
 tests/test_api_rebuild_wipe.py
 tests/test_cli.py
@@ -59,7 +64,10 @@ tests/test_cli_detailed.py
 tests/test_cli_embeddings.py
 tests/test_cli_json_parity.py
 tests/test_code_rag_simple.py
+tests/test_coderag_lifetime.py
 tests/test_csharp_discovery_detailed.py
+tests/test_db_connection.py
+tests/test_db_path.py
 tests/test_dependency_discovery.py
 tests/test_discovery_manager_detailed.py
 tests/test_discovery_providers_extra.py
@@ -72,18 +80,20 @@ tests/test_embedder_detailed.py
 tests/test_embedder_factory.py
 tests/test_embedder_interface.py
 tests/test_embedder_stubs.py
+tests/test_error_codes.py
 tests/test_factory_async.py
+tests/test_indexing_detailed.py
+tests/test_indexing_embeddings.py
+tests/test_indexing_extra.py
 tests/test_interfaces.py
 tests/test_js_discovery_detailed.py
 tests/test_languages.py
 tests/test_local_onnx_embedder.py
-tests/test_manager_detailed.py
-tests/test_manager_embeddings.py
-tests/test_manager_extra.py
 tests/test_models.py
 tests/test_multi_parser.py
 tests/test_openai_embedder.py
 tests/test_readme_library_usage.py
+tests/test_readme_lifetime_storage.py
 tests/test_readme_offline_embeddings.py
 tests/test_rust_discovery_detailed.py
 tests/test_storage_detailed.py

{agent_coderag-1.3.5 → agent_coderag-1.4.0}/code_rag/__init__.py

@@ -2,7 +2,9 @@ from code_rag.api.client import CodeRAG
 from code_rag.api.models import SyncResult, ApiReport, SetupResult
 from code_rag.core.models import KnowledgeUnit, UnitKind
 from code_rag.intelligence.distiller import DistillerConfig
-from code_rag.core.exceptions import CodeRAGError
+from code_rag.core.error_codes import ErrorCode
+from code_rag.core.exceptions import CodeRAGError, StorageBusyError
+from code_rag.paths import default_db_path
 
 __all__ = [
     "CodeRAG",
@@ -13,4 +15,7 @@ __all__ = [
     "UnitKind",
     "DistillerConfig",
     "CodeRAGError",
+    "ErrorCode",
+    "StorageBusyError",
+    "default_db_path",
 ]

agent_coderag-1.4.0/code_rag/api/client.py

@@ -0,0 +1,236 @@
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import AsyncIterator, Optional, Union
+
+from code_rag.api.models import ApiReport, SetupResult, SyncResult
+from code_rag.core.constants import DEFAULT_CONNECT_TIMEOUT_SECONDS
+from code_rag.core.interfaces import IEmbedder, IIntelligence, IParser
+from code_rag.core.models import KnowledgeUnit
+from code_rag.discovery.manager import DiscoveryManager
+from code_rag.discovery.providers.java import JavaDiscoveryProvider
+from code_rag.intelligence.distiller import Distiller, DistillerConfig
+from code_rag.paths import resolve_db_path
+from code_rag.services.config import (
+    distill_fields_requested,
+    embedding_fields_requested,
+    load_or_update_config,
+)
+from code_rag.services.discovery_api import run_api
+from code_rag.services.factory import create_stack
+from code_rag.services.search import run_search
+from code_rag.services.setup import run_setup
+from code_rag.services.indexing import IndexStack
+from code_rag.services.sync import SyncOptions, run_rebuild, run_sync
+from code_rag.storage.db_connection import AccessMode, open_db_connection
+from code_rag.storage.duckdb_impl import DuckDBStorage
+
+logger = logging.getLogger(__name__)
+
+
+class CodeRAG:  # pylint: disable=too-many-instance-attributes
+    """Public async facade: process-scoped stack + ephemeral DB per operation."""
+
+    def __init__(  # pylint: disable=too-many-arguments
+        self,
+        db: Optional[str] = None,
+        onnx: Optional[str] = None,
+        *,
+        root: Optional[Union[str, Path]] = None,
+        allow_build_execution: bool = False,
+        connect_timeout_seconds: float = DEFAULT_CONNECT_TIMEOUT_SECONDS,
+    ):
+        self._onnx = onnx
+        self._root = Path(root) if root is not None else Path.cwd()
+        self._allow_build_execution = allow_build_execution
+        self._connect_timeout_seconds = connect_timeout_seconds
+        self._db_path = resolve_db_path(db, root=self._root)
+        self._embedder: Optional[IEmbedder] = None
+        self._parser: Optional[IParser] = None
+        self._distiller: Optional[IIntelligence] = None
+        self._storage: Optional[DuckDBStorage] = None
+        self._op_lock = asyncio.Lock()
+        logger.info("Resolved database path: %s", self._db_path.resolve())
+
+    async def __aenter__(self) -> "CodeRAG":
+        return self
+
+    async def __aexit__(self, *_exc) -> None:
+        await self.close()
+
+    async def _ensure_stack(self) -> None:
+        if self._embedder is not None:
+            return
+        self._embedder, self._parser, self._distiller = await create_stack(self._onnx)
+
+    @asynccontextmanager
+    async def _with_storage(
+        self, mode: AccessMode, *, wipe: bool = False
+    ) -> AsyncIterator[DuckDBStorage]:
+        async with self._op_lock:
+            await self._ensure_stack()
+            if self._embedder is None:
+                raise RuntimeError("process stack is not initialized")
+            storage = await open_db_connection(
+                self._db_path,
+                self._embedder,
+                mode=mode,
+                connect_timeout_seconds=self._connect_timeout_seconds,
+                wipe=wipe,
+            )
+            self._storage = storage
+            try:
+                yield storage
+            finally:
+                await storage.close()
+                self._storage = None
+
+    @asynccontextmanager
+    async def _metadata_ro_connection(self) -> AsyncIterator[DuckDBStorage]:
+        storage = await open_db_connection(
+            self._db_path,
+            None,
+            mode=AccessMode.READ_ONLY,
+            connect_timeout_seconds=self._connect_timeout_seconds,
+        )
+        self._storage = storage
+        try:
+            yield storage
+        finally:
+            await storage.close()
+            self._storage = None
+
+    async def close(self) -> None:
+        async with self._op_lock:
+            if self._storage is not None:
+                await self._storage.close()
+                self._storage = None
+            if self._embedder is not None:
+                await self._embedder.close()
+                self._embedder = None
+            self._parser = None
+            self._distiller = None
+
+    async def config(  # pylint: disable=too-many-arguments
+        self,
+        *,
+        url: Optional[str] = None,
+        key: Optional[str] = None,
+        model: Optional[str] = None,
+        provider: Optional[str] = None,
+        embedding_url: Optional[str] = None,
+        embedding_key: Optional[str] = None,
+        embedding_model: Optional[str] = None,
+        embedding_provider: Optional[str] = None,
+        clear_embedding: bool = False,
+    ) -> DistillerConfig:
+        touch_embedding = embedding_fields_requested(
+            embedding_url=embedding_url,
+            embedding_key=embedding_key,
+            embedding_model=embedding_model,
+            embedding_provider=embedding_provider,
+            clear_embedding=clear_embedding,
+        )
+        touch_distill = distill_fields_requested(
+            url=url, key=key, model=model, provider=provider
+        )
+        result = load_or_update_config(
+            url=url,
+            key=key,
+            model=model,
+            provider=provider,
+            embedding_url=embedding_url,
+            embedding_key=embedding_key,
+            embedding_model=embedding_model,
+            embedding_provider=embedding_provider,
+            clear_embedding=clear_embedding,
+        )
+        if touch_embedding or touch_distill:
+            await self._invalidate_stack_after_config(
+                embedding=touch_embedding, distill=touch_distill
+            )
+        return result
+
+    async def _invalidate_stack_after_config(
+        self, *, embedding: bool, distill: bool
+    ) -> None:
+        """Refresh process stack pieces affected by config().
+
+        Embedding changes close and drop the embedder (full stack rebuild on
+        next op). Distill-only changes replace Distiller and keep the embedder.
+        """
+        async with self._op_lock:
+            if embedding and self._embedder is not None:
+                await self._embedder.close()
+                self._embedder = None
+                self._parser = None
+                self._distiller = None
+                return
+            if distill and self._distiller is not None:
+                self._distiller = Distiller(DistillerConfig.load())
+
+    async def setup(self, *, force: bool = False) -> SetupResult:
+        return await run_setup(force=force)
+
+    async def sync(
+        self,
+        path: Optional[str] = None,
+        *,
+        index_all: bool = False,
+        force: bool = False,
+    ) -> SyncResult:
+        if path is None and not index_all:
+            return SyncResult(status="success", indexed_files=0)
+        async with self._with_storage(AccessMode.READ_WRITE) as storage:
+            if self._parser is None or self._distiller is None:
+                raise RuntimeError("process stack is not initialized")
+            stack = IndexStack(storage, self._parser, self._distiller)
+            return await run_sync(
+                stack,
+                SyncOptions(
+                    root=self._root,
+                    path=path,
+                    index_all=index_all,
+                    force=force,
+                    allow_build_execution=self._allow_build_execution,
+                ),
+            )
+
+    async def search(self, query: str, *, limit: int = 5) -> list[KnowledgeUnit]:
+        async with self._with_storage(AccessMode.READ_ONLY) as storage:
+            return await run_search(storage, query, limit=limit)
+
+    async def _api_java(
+        self,
+        discovery: DiscoveryManager,
+        provider: JavaDiscoveryProvider,
+        library: str,
+        language: str,
+    ) -> ApiReport:
+        async with self._op_lock:
+            async with self._metadata_ro_connection() as storage:
+                provider.storage = storage
+                try:
+                    return await run_api(discovery, library, lang=language)
+                finally:
+                    provider.storage = None
+
+    async def api(self, library: str, *, lang: Optional[str] = None) -> ApiReport:
+        language = lang or "python"
+        discovery = DiscoveryManager()
+        provider = discovery.get_provider(language)
+        if isinstance(provider, JavaDiscoveryProvider):
+            return await self._api_java(discovery, provider, library, language)
+        return await run_api(discovery, library, lang=language)
+
+    async def rebuild(self) -> SyncResult:
+        async with self._with_storage(AccessMode.READ_WRITE, wipe=True) as storage:
+            if self._parser is None or self._distiller is None:
+                raise RuntimeError("process stack is not initialized")
+            stack = IndexStack(storage, self._parser, self._distiller)
+            return await run_rebuild(
+                stack,
+                root=self._root,
+                allow_build_execution=self._allow_build_execution,
+            )

{agent_coderag-1.3.5 → agent_coderag-1.4.0}/code_rag/core/constants.py

@@ -14,6 +14,7 @@ PAD_TOKEN = "[PAD]"  # nosec B105
 
 # Performance & Timeout Constants
 DEFAULT_SUBPROCESS_TIMEOUT = 30
+DEFAULT_CONNECT_TIMEOUT_SECONDS = 5.0
 METADATA_FETCH_TIMEOUT = 60
 LLM_REQUEST_TIMEOUT = 30
 MAX_CONCURRENT_TASKS = 10

agent_coderag-1.4.0/code_rag/core/error_codes.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class ErrorCode(str, Enum):
+    STORAGE_BUSY = "STORAGE_BUSY"
+    STORAGE_CORRUPT = "STORAGE_CORRUPT"
+    EMBEDDING_MISMATCH = "EMBEDDING_MISMATCH"

{agent_coderag-1.3.5 → agent_coderag-1.4.0}/code_rag/core/exceptions.py

@@ -2,15 +2,30 @@
 Custom exception hierarchy for CodeRAG.
 """
 
+from typing import Optional
+
+from .error_codes import ErrorCode
+
 
 class CodeRAGError(Exception):
     """Base class for all CodeRAG exceptions."""
 
+    def __init__(self, message: str = "", *, code: Optional[ErrorCode] = None):
+        super().__init__(message)
+        self.code = code
+
 
 class StorageError(CodeRAGError):
     """Raised when a storage operation fails."""
 
 
+class StorageBusyError(StorageError):
+    """Raised when storage is locked or busy."""
+
+    def __init__(self, message: str = "Storage is busy"):
+        super().__init__(message, code=ErrorCode.STORAGE_BUSY)
+
+
 class ParserError(CodeRAGError):
     """Raised when code parsing fails."""
 

{agent_coderag-1.3.5 → agent_coderag-1.4.0}/code_rag/discovery/manager.py

@@ -36,6 +36,10 @@ class DiscoveryManager:
         self._providers[language.lower()] = provider
         logger.debug("Registered discovery provider for %s", language)
 
+    def get_provider(self, language: str) -> Optional[IDiscoveryProvider]:
+        """Returns the provider for a language, if registered."""
+        return self._providers.get(language.lower())
+
     async def extract_api(self, library_name: str, language: str) -> str:
         """
         Extracts API for a library using the specified language provider.

{agent_coderag-1.3.5 → agent_coderag-1.4.0}/code_rag/discovery/providers/java.py

@@ -10,6 +10,10 @@ from ...parsers.tree_sitter import TreeSitterParser
 logger = logging.getLogger(__name__)
 
 
+def _cached_jar_miss_message(library_name: str) -> str:
+    return f"Error: Could not find cached JAR for '{library_name}'. Run 'sync' first."
+
+
 class JavaDiscoveryProvider(IDiscoveryProvider):
     """API discovery for Java libraries using bytecode/source analysis."""
 
@@ -26,11 +30,11 @@ class JavaDiscoveryProvider(IDiscoveryProvider):
         Extracts Java API from a cached JAR file.
         """
         if not self.storage:
-            return "Error: Storage required for Java API discovery."
+            return _cached_jar_miss_message(library_name)
 
         jar_path = await self.storage.get_dependency_path(library_name)
         if not jar_path or not os.path.exists(jar_path):
-            return f"Error: Could not find cached JAR for '{library_name}'. Run 'sync' first."
+            return _cached_jar_miss_message(library_name)
 
         output = [f"# Public API for Java Library '{library_name}':"]
         try: