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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-coderag
-Version: 1.4.0
+Version: 1.4.1
 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
@@ -189,10 +189,10 @@ async def main():
 - **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).
+- **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. An index file that exists but has no embeddings table (e.g. opened/written without a completed vector sync) raises `StorageError` with `ErrorCode.EMBEDDINGS_MISSING` — run `sync` (library: `CodeRAG.sync`) before search. With `--json`, success is a hit array; errors are `{"status":"error","message":...}` and include `"code"` when the exception carries an `ErrorCode`.
 - **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`).
+- **Errors:** catch `CodeRAGError` and inspect `.code` — `STORAGE_BUSY`, `STORAGE_CORRUPT`, `EMBEDDING_MISMATCH`, `EMBEDDINGS_MISSING` (`from code_rag import ErrorCode`).
 
 ---
 

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

@@ -143,10 +143,10 @@ async def main():
 - **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).
+- **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. An index file that exists but has no embeddings table (e.g. opened/written without a completed vector sync) raises `StorageError` with `ErrorCode.EMBEDDINGS_MISSING` — run `sync` (library: `CodeRAG.sync`) before search. With `--json`, success is a hit array; errors are `{"status":"error","message":...}` and include `"code"` when the exception carries an `ErrorCode`.
 - **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`).
+- **Errors:** catch `CodeRAGError` and inspect `.code` — `STORAGE_BUSY`, `STORAGE_CORRUPT`, `EMBEDDING_MISMATCH`, `EMBEDDINGS_MISSING` (`from code_rag import ErrorCode`).
 
 ---
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-coderag
-Version: 1.4.0
+Version: 1.4.1
 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
@@ -189,10 +189,10 @@ async def main():
 - **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).
+- **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. An index file that exists but has no embeddings table (e.g. opened/written without a completed vector sync) raises `StorageError` with `ErrorCode.EMBEDDINGS_MISSING` — run `sync` (library: `CodeRAG.sync`) before search. With `--json`, success is a hit array; errors are `{"status":"error","message":...}` and include `"code"` when the exception carries an `ErrorCode`.
 - **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`).
+- **Errors:** catch `CodeRAGError` and inspect `.code` — `STORAGE_BUSY`, `STORAGE_CORRUPT`, `EMBEDDING_MISMATCH`, `EMBEDDINGS_MISSING` (`from code_rag import ErrorCode`).
 
 ---
 

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

@@ -33,6 +33,7 @@ code_rag/discovery/providers/javascript.py
 code_rag/discovery/providers/python.py
 code_rag/discovery/providers/rust.py
 code_rag/entry/__init__.py
+code_rag/entry/args.py
 code_rag/entry/cli.py
 code_rag/intelligence/__init__.py
 code_rag/intelligence/distiller.py
@@ -63,6 +64,7 @@ tests/test_cli.py
 tests/test_cli_detailed.py
 tests/test_cli_embeddings.py
 tests/test_cli_json_parity.py
+tests/test_cli_startup.py
 tests/test_code_rag_simple.py
 tests/test_coderag_lifetime.py
 tests/test_csharp_discovery_detailed.py

agent_coderag-1.4.1/agent_coderag.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agent-coderag = code_rag.entry.args:main

agent_coderag-1.4.1/code_rag/__init__.py

@@ -0,0 +1,69 @@
+"""Public package surface. Imports stay lazy so ``agent-coderag --help`` does not load DuckDB, ONNX, or LiteLLM."""
+
+import importlib
+
+# Names are assigned so static checkers accept ``__all__``, then removed so
+# attribute access goes through ``__getattr__`` and stays lazy.
+CodeRAG = None
+SyncResult = None
+ApiReport = None
+SetupResult = None
+KnowledgeUnit = None
+UnitKind = None
+DistillerConfig = None
+CodeRAGError = None
+ErrorCode = None
+StorageBusyError = None
+default_db_path = None
+
+__all__ = [
+    "CodeRAG",
+    "SyncResult",
+    "ApiReport",
+    "SetupResult",
+    "KnowledgeUnit",
+    "UnitKind",
+    "DistillerConfig",
+    "CodeRAGError",
+    "ErrorCode",
+    "StorageBusyError",
+    "default_db_path",
+]
+
+_EXPORTS = {
+    "CodeRAG": ("code_rag.api.client", "CodeRAG"),
+    "SyncResult": ("code_rag.api.models", "SyncResult"),
+    "ApiReport": ("code_rag.api.models", "ApiReport"),
+    "SetupResult": ("code_rag.api.models", "SetupResult"),
+    "KnowledgeUnit": ("code_rag.core.models", "KnowledgeUnit"),
+    "UnitKind": ("code_rag.core.models", "UnitKind"),
+    "DistillerConfig": ("code_rag.intelligence.distiller", "DistillerConfig"),
+    "CodeRAGError": ("code_rag.core.exceptions", "CodeRAGError"),
+    "ErrorCode": ("code_rag.core.error_codes", "ErrorCode"),
+    "StorageBusyError": ("code_rag.core.exceptions", "StorageBusyError"),
+    "default_db_path": ("code_rag.paths", "default_db_path"),
+}
+
+del (
+    CodeRAG,
+    SyncResult,
+    ApiReport,
+    SetupResult,
+    KnowledgeUnit,
+    UnitKind,
+    DistillerConfig,
+    CodeRAGError,
+    ErrorCode,
+    StorageBusyError,
+    default_db_path,
+)
+
+
+def __getattr__(name):
+    target = _EXPORTS.get(name)
+    if target is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    module_name, attr = target
+    value = getattr(importlib.import_module(module_name), attr)
+    globals()[name] = value
+    return value

{agent_coderag-1.4.0 → agent_coderag-1.4.1}/code_rag/core/error_codes.py

@@ -5,3 +5,4 @@ class ErrorCode(str, Enum):
     STORAGE_BUSY = "STORAGE_BUSY"
     STORAGE_CORRUPT = "STORAGE_CORRUPT"
     EMBEDDING_MISMATCH = "EMBEDDING_MISMATCH"
+    EMBEDDINGS_MISSING = "EMBEDDINGS_MISSING"

agent_coderag-1.4.1/code_rag/entry/args.py

@@ -0,0 +1,113 @@
+"""Argparse entry. Importing this module must stay free of DuckDB, ONNX, and LiteLLM."""
+
+import argparse
+import importlib
+import logging
+import sys
+
+from code_rag.core.constants import DEFAULT_CONNECT_TIMEOUT_SECONDS
+from code_rag.core.exceptions import CodeRAGError
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="CodeRAG: API Knowledge Bridge.")
+    parser.add_argument(
+        "--db",
+        default=None,
+        help=(
+            "DuckDB index file. Default: resolve legacy code_rag.db in cwd/root, "
+            "else use .coderag.db under project root."
+        ),
+    )
+    parser.add_argument("--onnx", help="Path to local ONNX model file.")
+    parser.add_argument(
+        "--connect-timeout",
+        dest="connect_timeout",
+        type=float,
+        default=DEFAULT_CONNECT_TIMEOUT_SECONDS,
+        help=(
+            "Seconds to wait for a DuckDB file lock before StorageBusyError "
+            f"(default {DEFAULT_CONNECT_TIMEOUT_SECONDS:g}). 0 = no retry."
+        ),
+    )
+    parser.add_argument(
+        "--verbose", action="store_true", help="Enable verbose logging."
+    )
+    parser.add_argument("--json", action="store_true", help="Output results in JSON.")
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    sync = subparsers.add_parser("sync", help="Index code units.")
+    sync.add_argument("path", nargs="?", help="File or directory to index.")
+    sync.add_argument("--all", action="store_true", help="Index all supported files.")
+    sync.add_argument("--force", action="store_true", help="Force re-distillation.")
+    sync.add_argument(
+        "--allow-build-execution",
+        action="store_true",
+        help="Execute repository Maven/Gradle build files during dependency sync (trusted projects only).",
+    )
+
+    search = subparsers.add_parser("search", help="Semantic search.")
+    search.add_argument("query", help="Natural language query.")
+    search.add_argument("--limit", type=int, default=5, help="Result limit.")
+
+    api = subparsers.add_parser("api", help="Discover library API.")
+    api.add_argument("library", help="Library name (e.g., pydantic).")
+    api.add_argument("--lang", help="Target language.")
+
+    cfg = subparsers.add_parser("config", help="Manage LLM configuration.")
+    cfg.add_argument("--url", help="API base URL.")
+    cfg.add_argument("--key", help="API key.")
+    cfg.add_argument("--model", help="Model name.")
+    cfg.add_argument("--provider", help="Provider name (openai, ollama).")
+    cfg.add_argument(
+        "--embedding-url", dest="embedding_url", help="Embedding API base URL."
+    )
+    cfg.add_argument("--embedding-key", dest="embedding_key", help="Embedding API key.")
+    cfg.add_argument(
+        "--embedding-model", dest="embedding_model", help="Remote embedding model id."
+    )
+    cfg.add_argument(
+        "--embedding-provider",
+        dest="embedding_provider",
+        help="LiteLLM custom_llm_provider for embeddings.",
+    )
+    cfg.add_argument(
+        "--clear-embedding",
+        dest="clear_embedding",
+        action="store_true",
+        help="Clear remote embedding config (local MiniLM).",
+    )
+
+    setup = subparsers.add_parser("setup", help="Initial setup (download models).")
+    setup.add_argument("--force", action="store_true", help="Force model redownload.")
+
+    subparsers.add_parser("rebuild", help="Full re-index of the project.")
+    return parser
+
+
+def main() -> None:
+    parser = build_parser()
+    try:
+        args = parser.parse_args()
+
+        if args.verbose:
+            logging.basicConfig(level=logging.INFO)
+        else:
+            logging.basicConfig(level=logging.WARNING)
+
+        if not args.command:
+            parser.print_help()
+            return
+
+        # Heavy stack (DuckDB, ONNX, parsers) loads only for a real subcommand.
+        dispatch = importlib.import_module("code_rag.entry.cli").dispatch
+        dispatch(args)
+    except CodeRAGError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        sys.exit(0)
+    except Exception as exc:
+        logging.getLogger(__name__).error("Unexpected error: %s", exc)
+        sys.exit(1)

{agent_coderag-1.4.0 → agent_coderag-1.4.1}/code_rag/entry/cli.py

@@ -1,6 +1,5 @@
 import logging
 import asyncio
-import argparse
 import sys
 import json
 from pathlib import Path
@@ -43,7 +42,6 @@ __all__ = [
     "get_global_dir",
     "requests",
     "validate_path",
-    "main",
 ]
 
 
@@ -59,6 +57,14 @@ def _coderag_from_args(args) -> CodeRAG:
     )
 
 
+def _emit_json_error(exc: Exception) -> None:
+    payload = {"status": "error", "message": str(exc)}
+    code = getattr(exc, "code", None)
+    if isinstance(exc, CodeRAGError) and code is not None:
+        payload["code"] = code.value if hasattr(code, "value") else str(code)
+    print(json.dumps(payload))
+
+
 def load_ignore_patterns() -> pathspec.PathSpec:
     """Loads ignore patterns from the current directory's .gitignore or defaults."""
     return sync_service.load_ignore_patterns(Path.cwd())
@@ -105,7 +111,7 @@ async def sync_cmd(args):
     except Exception as e:
         logger.error("Sync failed: %s", e)
         if args.json:
-            print(json.dumps({"status": "error", "message": str(e)}))
+            _emit_json_error(e)
         else:
             print(f"Error: {e}", file=sys.stderr)
         raise SystemExit(1) from e
@@ -146,7 +152,7 @@ async def search_cmd(args):
     except Exception as e:
         logger.error("Search failed: %s", e)
         if args.json:
-            print(json.dumps({"status": "error", "message": str(e)}))
+            _emit_json_error(e)
         else:
             print(f"Error: {e}", file=sys.stderr)
         raise SystemExit(1) from e
@@ -166,7 +172,7 @@ async def api_cmd(args):
     except Exception as e:
         logger.error("API discovery failed: %s", e)
         if args.json:
-            print(json.dumps({"status": "error", "message": str(e)}))
+            _emit_json_error(e)
         else:
             print(f"Error: {e}", file=sys.stderr)
     finally:
@@ -277,7 +283,7 @@ async def rebuild_cmd(args):
     except Exception as exc:
         logger.error("Rebuild failed: %s", exc)
         if args.json:
-            print(json.dumps({"status": "error", "message": str(exc)}))
+            _emit_json_error(exc)
         else:
             print(f"Error: {exc}", file=sys.stderr)
         raise SystemExit(1) from exc
@@ -285,122 +291,16 @@ async def rebuild_cmd(args):
         await rag.close()
 
 
-def _build_arg_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(description="CodeRAG: API Knowledge Bridge.")
-    parser.add_argument(
-        "--db",
-        default=None,
-        help=(
-            "DuckDB index file. Default: resolve legacy code_rag.db in cwd/root, "
-            "else use .coderag.db under project root."
-        ),
-    )
-    parser.add_argument("--onnx", help="Path to local ONNX model file.")
-    parser.add_argument(
-        "--connect-timeout",
-        dest="connect_timeout",
-        type=float,
-        default=DEFAULT_CONNECT_TIMEOUT_SECONDS,
-        help=(
-            "Seconds to wait for a DuckDB file lock before StorageBusyError "
-            f"(default {DEFAULT_CONNECT_TIMEOUT_SECONDS:g}). 0 = no retry."
-        ),
-    )
-    parser.add_argument(
-        "--verbose", action="store_true", help="Enable verbose logging."
-    )
-    parser.add_argument("--json", action="store_true", help="Output results in JSON.")
-
-    subparsers = parser.add_subparsers(dest="command")
-
-    # Sync
-    sync = subparsers.add_parser("sync", help="Index code units.")
-    sync.add_argument("path", nargs="?", help="File or directory to index.")
-    sync.add_argument("--all", action="store_true", help="Index all supported files.")
-    sync.add_argument("--force", action="store_true", help="Force re-distillation.")
-    sync.add_argument(
-        "--allow-build-execution",
-        action="store_true",
-        help="Execute repository Maven/Gradle build files during dependency sync (trusted projects only).",
-    )
-
-    # Search
-    search = subparsers.add_parser("search", help="Semantic search.")
-    search.add_argument("query", help="Natural language query.")
-    search.add_argument("--limit", type=int, default=5, help="Result limit.")
-
-    # API
-    api = subparsers.add_parser("api", help="Discover library API.")
-    api.add_argument("library", help="Library name (e.g., pydantic).")
-    api.add_argument("--lang", help="Target language.")
-
-    # Config
-    cfg = subparsers.add_parser("config", help="Manage LLM configuration.")
-    cfg.add_argument("--url", help="API base URL.")
-    cfg.add_argument("--key", help="API key.")
-    cfg.add_argument("--model", help="Model name.")
-    cfg.add_argument("--provider", help="Provider name (openai, ollama).")
-    cfg.add_argument(
-        "--embedding-url", dest="embedding_url", help="Embedding API base URL."
-    )
-    cfg.add_argument("--embedding-key", dest="embedding_key", help="Embedding API key.")
-    cfg.add_argument(
-        "--embedding-model", dest="embedding_model", help="Remote embedding model id."
-    )
-    cfg.add_argument(
-        "--embedding-provider",
-        dest="embedding_provider",
-        help="LiteLLM custom_llm_provider for embeddings.",
-    )
-    cfg.add_argument(
-        "--clear-embedding",
-        dest="clear_embedding",
-        action="store_true",
-        help="Clear remote embedding config (local MiniLM).",
-    )
-
-    # Setup
-    setup = subparsers.add_parser("setup", help="Initial setup (download models).")
-    setup.add_argument("--force", action="store_true", help="Force model redownload.")
-
-    # Rebuild
-    subparsers.add_parser("rebuild", help="Full re-index of the project.")
-    return parser
-
-
-def main():
-    parser = _build_arg_parser()
-    try:
-        args = parser.parse_args()
-
-        if args.verbose:
-            logging.basicConfig(level=logging.INFO)
-        else:
-            logging.basicConfig(level=logging.WARNING)
-
-        if args.command == "sync":
-            asyncio.run(sync_cmd(args))
-        elif args.command == "search":
-            asyncio.run(search_cmd(args))
-        elif args.command == "api":
-            asyncio.run(api_cmd(args))
-        elif args.command == "config":
-            config_cmd(args)
-        elif args.command == "setup":
-            asyncio.run(setup_cmd(args))
-        elif args.command == "rebuild":
-            asyncio.run(rebuild_cmd(args))
-        else:
-            parser.print_help()
-    except CodeRAGError as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-    except KeyboardInterrupt:
-        sys.exit(0)
-    except Exception as e:
-        logger.error("Unexpected error: %s", e)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
+def dispatch(args) -> None:
+    if args.command == "sync":
+        asyncio.run(sync_cmd(args))
+    elif args.command == "search":
+        asyncio.run(search_cmd(args))
+    elif args.command == "api":
+        asyncio.run(api_cmd(args))
+    elif args.command == "config":
+        config_cmd(args)
+    elif args.command == "setup":
+        asyncio.run(setup_cmd(args))
+    elif args.command == "rebuild":
+        asyncio.run(rebuild_cmd(args))

{agent_coderag-1.4.0 → agent_coderag-1.4.1}/code_rag/intelligence/distiller.py

@@ -1,7 +1,7 @@
 import logging
 import json
+import importlib
 from typing import Optional
-import litellm
 from pydantic import BaseModel, ConfigDict, field_validator
 from ..core.exceptions import IntelligenceError
 from ..core.interfaces import IIntelligence
@@ -114,6 +114,7 @@ SUMMARY:
         if self.config.provider == "ollama" and not model_id.startswith("ollama/"):
             model_id = f"ollama/{model_id}"
 
+        litellm = importlib.import_module("litellm")
         response = await litellm.acompletion(
             model=model_id,
             messages=[{"role": "user", "content": prompt}],

{agent_coderag-1.4.0 → agent_coderag-1.4.1}/code_rag/intelligence/openai_embedder.py

@@ -1,8 +1,8 @@
 import asyncio
+import importlib
 import logging
 from typing import Optional
 
-import litellm
 import numpy as np
 
 from ..core.constants import EMBEDDING_REQUEST_TIMEOUT
@@ -74,6 +74,8 @@ class OpenAICompatEmbedder(IEmbedder):
         }
         if self._provider is not None:
             kwargs["custom_llm_provider"] = self._provider
+        litellm = importlib.import_module("litellm")
+
         async with self._embed_lock:
             try:
                 response = await litellm.aembedding(**kwargs)

{agent_coderag-1.4.0 → agent_coderag-1.4.1}/code_rag/storage/duckdb_impl.py

@@ -18,6 +18,10 @@ from ..core.exceptions import StorageError, IntelligenceError
 
 logger = logging.getLogger(__name__)
 
+EMBEDDINGS_MISSING_MSG = (
+    "Embeddings table is missing; run sync (CodeRAG.sync) before search."
+)
+
 
 class AccessMode(str, Enum):
     """Whether a connection may write. Not part of the public package API."""
@@ -315,6 +319,16 @@ class DuckDBStorage(IStorage):
             self._pending_wipe = False
 
     async def _bind_embeddings(self) -> None:
+        if self.mode is AccessMode.READ_ONLY:
+            exists = await self._run_on_executor(
+                lambda: _table_exists(self.conn, "unit_embeddings")
+            )
+            if not exists:
+                raise StorageError(
+                    EMBEDDINGS_MISSING_MSG,
+                    code=ErrorCode.EMBEDDINGS_MISSING,
+                )
+
         dim = await bind_embedder_dimension(
             self.conn,
             self.embedder,

{agent_coderag-1.4.0 → agent_coderag-1.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agent-coderag"
-version = "1.4.0"
+version = "1.4.1"
 description = "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."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -57,7 +57,7 @@ Issues = "https://github.com/naranor/agent-coderag/issues"
 Changelog = "https://github.com/naranor/agent-coderag/blob/main/CHANGELOG.md"
 
 [project.scripts]
-agent-coderag = "code_rag.entry.cli:main"
+agent-coderag = "code_rag.entry.args:main"
 
 [tool.setuptools]
 package-data = {"*" = ["*.md"]}

{agent_coderag-1.4.0 → agent_coderag-1.4.1}/tests/test_cli_detailed.py

@@ -6,6 +6,7 @@ from io import StringIO
 from unittest.mock import MagicMock, patch, AsyncMock
 from pathlib import Path
 
+from code_rag.entry import args as cli_args
 from code_rag.entry import cli
 from code_rag.core.exceptions import CodeRAGError
 from code_rag.api.models import ApiReport
@@ -175,6 +176,43 @@ class TestCLIDetailed:
                 data = json.loads(sys.stdout.getvalue())
                 assert data["status"] == "error"
                 assert "Database file not found" in data["message"]
+                assert "code" not in data
+            finally:
+                sys.stdout = old_stdout
+            instances[0].close.assert_awaited()
+
+    @pytest.mark.asyncio
+    async def test_search_cmd_json_error_includes_code(self):
+        from code_rag.core.error_codes import ErrorCode
+        from code_rag.core.exceptions import StorageError
+
+        fake_cls, instances = fake_coderag_class(
+            search=AsyncMock(
+                side_effect=StorageError(
+                    "Embeddings table is missing; run sync (CodeRAG.sync) before search.",
+                    code=ErrorCode.EMBEDDINGS_MISSING,
+                )
+            )
+        )
+        with patch("code_rag.entry.cli.CodeRAG", fake_cls):
+            args = argparse.Namespace(
+                db="x.db",
+                onnx=None,
+                verbose=False,
+                json=True,
+                query="auth",
+                limit=5,
+            )
+            old_stdout = sys.stdout
+            sys.stdout = StringIO()
+            try:
+                with pytest.raises(SystemExit) as exc:
+                    await cli.search_cmd(args)
+                assert exc.value.code == 1
+                data = json.loads(sys.stdout.getvalue())
+                assert data["status"] == "error"
+                assert data["code"] == "EMBEDDINGS_MISSING"
+                assert "sync" in data["message"]
             finally:
                 sys.stdout = old_stdout
             instances[0].close.assert_awaited()
@@ -350,7 +388,7 @@ class TestCLIDetailed:
     def test_cli_main_exception_handling(self):
         """Test main entry point handles exceptions gracefully."""
         with patch(
-            "code_rag.entry.cli.argparse.ArgumentParser.parse_args"
+            "code_rag.entry.args.argparse.ArgumentParser.parse_args"
         ) as mock_parse, patch("code_rag.entry.cli.asyncio.run"):
             mock_parse.side_effect = CodeRAGError("Known Error")
 
@@ -358,7 +396,7 @@ class TestCLIDetailed:
             sys.stderr = StringIO()
             try:
                 with pytest.raises(SystemExit) as exc:
-                    cli.main()
+                    cli_args.main()
                 assert exc.value.code == 1
                 assert "Known Error" in sys.stderr.getvalue()
             finally:

{agent_coderag-1.4.0 → agent_coderag-1.4.1}/tests/test_cli_embeddings.py

@@ -7,6 +7,7 @@ from unittest.mock import patch
 import pytest
 
 from code_rag.core.exceptions import IntelligenceError
+from code_rag.entry import args as cli_args
 from code_rag.entry import cli
 from code_rag.intelligence.distiller import DistillerConfig
 from tests.fake_coderag import fake_coderag_class
@@ -206,6 +207,6 @@ def test_argparse_embedding_dests():
             ],
         ),
     ):
-        cli.main()
+        cli_args.main()
     assert captured["clear"] is True
     assert captured["eurl"] == "http://e"