agent-coderag 1.3.2__tar.gz → 1.3.3__tar.gz

{agent_coderag-1.3.2/agent_coderag.egg-info → agent_coderag-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-coderag
-Version: 1.3.2
+Version: 1.3.3
 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
@@ -29,6 +29,7 @@ Requires-Dist: onnxruntime
 Requires-Dist: tokenizers
 Requires-Dist: pydantic
 Requires-Dist: httpx
+Requires-Dist: requests
 Requires-Dist: aiofiles
 Requires-Dist: pathspec
 Requires-Dist: tree-sitter
@@ -148,6 +149,21 @@ agent-coderag api fmt
 
 ---
 
+## Library Usage
+
+```python
+from code_rag import CodeRAG
+
+async def main():
+    async with CodeRAG(db="code_rag.db") as rag:
+        await rag.setup()
+        await rag.sync(index_all=True)
+        hits = await rag.search("authentication middleware", limit=5)
+        report = await rag.api("pydantic", lang="python")
+```
+
+---
+
 ## Supported Ecosystems (Discovery)
 
 | Language | Method | Discovery Source |

{agent_coderag-1.3.2 → agent_coderag-1.3.3}/README.md

@@ -103,6 +103,21 @@ agent-coderag api fmt
 
 ---
 
+## Library Usage
+
+```python
+from code_rag import CodeRAG
+
+async def main():
+    async with CodeRAG(db="code_rag.db") as rag:
+        await rag.setup()
+        await rag.sync(index_all=True)
+        hits = await rag.search("authentication middleware", limit=5)
+        report = await rag.api("pydantic", lang="python")
+```
+
+---
+
 ## Supported Ecosystems (Discovery)
 
 | Language | Method | Discovery Source |

{agent_coderag-1.3.2 → agent_coderag-1.3.3/agent_coderag.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-coderag
-Version: 1.3.2
+Version: 1.3.3
 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
@@ -29,6 +29,7 @@ Requires-Dist: onnxruntime
 Requires-Dist: tokenizers
 Requires-Dist: pydantic
 Requires-Dist: httpx
+Requires-Dist: requests
 Requires-Dist: aiofiles
 Requires-Dist: pathspec
 Requires-Dist: tree-sitter
@@ -148,6 +149,21 @@ agent-coderag api fmt
 
 ---
 
+## Library Usage
+
+```python
+from code_rag import CodeRAG
+
+async def main():
+    async with CodeRAG(db="code_rag.db") as rag:
+        await rag.setup()
+        await rag.sync(index_all=True)
+        hits = await rag.search("authentication middleware", limit=5)
+        report = await rag.api("pydantic", lang="python")
+```
+
+---
+
 ## Supported Ecosystems (Discovery)
 
 | Language | Method | Discovery Source |

{agent_coderag-1.3.2 → agent_coderag-1.3.3}/agent_coderag.egg-info/SOURCES.txt

@@ -9,6 +9,9 @@ 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/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/exceptions.py
@@ -37,10 +40,20 @@ code_rag/parsers/__init__.py
 code_rag/parsers/languages.py
 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/discovery_api.py
+code_rag/services/factory.py
+code_rag/services/search.py
+code_rag/services/setup.py
+code_rag/services/sync.py
 code_rag/storage/__init__.py
 code_rag/storage/duckdb_impl.py
+tests/test_api_client.py
+tests/test_api_models.py
 tests/test_cli.py
 tests/test_cli_detailed.py
+tests/test_cli_json_parity.py
 tests/test_code_rag_simple.py
 tests/test_csharp_discovery_detailed.py
 tests/test_dependency_discovery.py
@@ -58,6 +71,7 @@ tests/test_manager_detailed.py
 tests/test_manager_extra.py
 tests/test_models.py
 tests/test_multi_parser.py
+tests/test_readme_library_usage.py
 tests/test_rust_discovery_detailed.py
 tests/test_storage_detailed.py
 tests/test_tree_sitter_parser.py

{agent_coderag-1.3.2 → agent_coderag-1.3.3}/agent_coderag.egg-info/requires.txt

@@ -5,6 +5,7 @@ onnxruntime
 tokenizers
 pydantic
 httpx
+requests
 aiofiles
 pathspec
 tree-sitter

agent_coderag-1.3.3/code_rag/__init__.py

@@ -0,0 +1,16 @@
+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
+
+__all__ = [
+    "CodeRAG",
+    "SyncResult",
+    "ApiReport",
+    "SetupResult",
+    "KnowledgeUnit",
+    "UnitKind",
+    "DistillerConfig",
+    "CodeRAGError",
+]

agent_coderag-1.3.3/code_rag/api/__init__.py

@@ -0,0 +1,6 @@
+"""Public API package for CodeRAG.
+
+`CodeRAG` lives in `code_rag.api.client` and is re-exported from top-level
+`code_rag`. Import models from `code_rag.api.models` directly; this package
+init stays empty to avoid circular imports with `code_rag.services.*`.
+"""

agent_coderag-1.3.3/code_rag/api/client.py

@@ -0,0 +1,87 @@
+from pathlib import Path
+from typing import Optional, Union
+
+from code_rag.api.models import ApiReport, SetupResult, SyncResult
+from code_rag.core.models import KnowledgeUnit
+from code_rag.intelligence.distiller import DistillerConfig
+from code_rag.services.config import load_or_update_config
+from code_rag.services.discovery_api import run_api
+from code_rag.services.factory import create_manager
+from code_rag.services.search import run_search
+from code_rag.services.setup import run_setup
+from code_rag.services.sync import run_rebuild, run_sync
+
+
+class CodeRAG:
+    """Public async facade over CodeRAG services and the storage/search manager."""
+
+    def __init__(
+        self,
+        db: str = "code_rag.db",
+        onnx: Optional[str] = None,
+        *,
+        root: Optional[Union[str, Path]] = None,
+        allow_build_execution: bool = False,
+    ):
+        self._db = db
+        self._onnx = onnx
+        self._root = Path(root) if root is not None else Path.cwd()
+        self._allow_build_execution = allow_build_execution
+        self._manager = None
+
+    async def __aenter__(self) -> "CodeRAG":
+        return self
+
+    async def __aexit__(self, *_exc) -> None:
+        await self.close()
+
+    async def close(self) -> None:
+        if self._manager is not None:
+            await self._manager.close()
+            self._manager = None
+
+    def _ensure_manager(self):
+        if self._manager is None:
+            self._manager = create_manager(
+                self._db, self._onnx, allow_build_execution=self._allow_build_execution
+            )
+        return self._manager
+
+    async def config(
+        self,
+        *,
+        url: Optional[str] = None,
+        key: Optional[str] = None,
+        model: Optional[str] = None,
+        provider: Optional[str] = None,
+    ) -> DistillerConfig:
+        return load_or_update_config(url=url, key=key, model=model, provider=provider)
+
+    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)
+        return await run_sync(
+            self._ensure_manager(),
+            root=self._root,
+            path=path,
+            index_all=index_all,
+            force=force,
+        )
+
+    async def search(self, query: str, *, limit: int = 5) -> list[KnowledgeUnit]:
+        return await run_search(self._ensure_manager(), query, limit=limit)
+
+    async def api(self, library: str, *, lang: Optional[str] = None) -> ApiReport:
+        return await run_api(self._ensure_manager(), library, lang=lang)
+
+    async def rebuild(self) -> SyncResult:
+        return await run_rebuild(self._ensure_manager(), root=self._root)

agent_coderag-1.3.3/code_rag/api/models.py

@@ -0,0 +1,20 @@
+from pydantic import BaseModel, ConfigDict
+
+
+class SyncResult(BaseModel):
+    status: str
+    indexed_files: int
+
+
+class ApiReport(BaseModel):
+    library: str
+    language: str
+    report: str
+
+
+class SetupResult(BaseModel):
+    model_config = ConfigDict(protected_namespaces=())
+
+    model_dir: str
+    downloaded: list[str]
+    skipped: list[str]

{agent_coderag-1.3.2 → agent_coderag-1.3.3}/code_rag/core/manager.py

@@ -19,7 +19,7 @@ class CodeRAGManager:
     Orchestrates the RAG workflow: parsing, distillation, and storage.
     """
 
-    def __init__(
+    def __init__(  # pylint: disable=too-many-arguments,too-many-positional-arguments
         self,
         storage: IStorage,
         parser: IParser,

{agent_coderag-1.3.2 → agent_coderag-1.3.3}/code_rag/entry/cli.py

@@ -1,6 +1,5 @@
 import logging
 import asyncio
-import os
 import argparse
 import sys
 import json
@@ -15,49 +14,50 @@ from ..storage.duckdb_impl import DuckDBStorage
 from ..parsers.multi_parser import MultiParser
 from ..intelligence.distiller import Distiller, DistillerConfig
 from ..intelligence.embedder import Embedder, get_global_dir
-from ..parsers.languages import EXTENSION_TO_LANGUAGE
 from ..core.utils import validate_path
-from ..core.exceptions import CodeRAGError, DiscoveryError
+from ..core.exceptions import CodeRAGError
+from ..services import sync as sync_service
+from ..services.discovery_api import run_api
+from ..services.search import run_search
+from ..services.setup import run_setup
 
 logger = logging.getLogger(__name__)
 
+# Legacy compatibility surface: these names are imported/patched by existing
+# integrations and tests, so they must stay resolvable on this module.
+__all__ = [
+    "get_manager",
+    "load_ignore_patterns",
+    "should_index",
+    "sync_cmd",
+    "search_cmd",
+    "api_cmd",
+    "config_cmd",
+    "setup_cmd",
+    "rebuild_cmd",
+    "DistillerConfig",
+    "Embedder",
+    "DuckDBStorage",
+    "MultiParser",
+    "Distiller",
+    "get_global_dir",
+    "requests",
+    "validate_path",
+    "main",
+]
+
 
 def load_ignore_patterns() -> pathspec.PathSpec:
-    """Loads ignore patterns from .gitignore or defaults."""
-    lines = []
-    if os.path.exists(".gitignore"):
-        with open(".gitignore", "r", encoding="utf-8") as f:
-            lines = f.readlines()
-
-    common_excludes = [
-        "node_modules/",
-        "venv/",
-        ".venv/",
-        "__pycache__/",
-        ".git/",
-        ".idea/",
-        ".vscode/",
-        ".onnx",
-        ".db",
-        ".ai/",
-    ]
-    return pathspec.PathSpec.from_lines("gitignore", lines + common_excludes)
+    """Loads ignore patterns from the current directory's .gitignore or defaults."""
+    return sync_service.load_ignore_patterns(Path.cwd())
 
 
 def should_index(path: Path, ignore_spec: Optional[pathspec.PathSpec] = None) -> bool:
     """Filters files that should NOT be indexed."""
-    # Convert backslashes to forward slashes for cross-platform matching
-    path_str = str(path).replace(os.sep, "/")
-
-    # 1. Check against ignore spec (including .gitignore and common excludes)
-    if ignore_spec and ignore_spec.match_file(path_str):
-        return False
-
-    return path.suffix.lower() in EXTENSION_TO_LANGUAGE
+    return sync_service.should_index(path, ignore_spec)
 
 
 async def sync_cmd(args):
-    # Validate input path
     if args.path:
         args.path = str(validate_path(args.path))
 
@@ -67,39 +67,13 @@ async def sync_cmd(args):
         allow_build_execution=getattr(args, "allow_build_execution", False),
     )
     try:
-        ignore_spec = load_ignore_patterns()
-
-        # Task 2: Sync dependencies before indexing
-        try:
-            await manager.sync_dependencies(args.path or ".")
-        except DiscoveryError as de:
-            logger.warning("Dependency discovery failed: %s", de)
-
-        if args.path:
-            target_path = Path(args.path)
-            if target_path.is_file():
-                if should_index(target_path, ignore_spec):
-                    await manager.sync_file(str(target_path), force_distill=args.force)
-            else:
-                paths = [
-                    str(p)
-                    for p in target_path.rglob("*")
-                    if p.is_file() and should_index(p, ignore_spec)
-                ]
-
-                if args.verbose:
-                    logger.info("Indexing %d files...", len(paths))
-                await manager.sync_project(paths, force_distill=args.force)
-        elif args.all:
-            paths = [
-                str(p)
-                for p in Path(".").rglob("*")
-                if p.is_file() and should_index(p, ignore_spec)
-            ]
-
-            if args.verbose:
-                logger.info("Indexing %d files...", len(paths))
-            await manager.sync_project(paths, force_distill=args.force)
+        await sync_service.run_sync(
+            manager,
+            root=Path.cwd(),
+            path=args.path,
+            index_all=bool(args.all),
+            force=bool(args.force),
+        )
 
         if args.json:
             print(json.dumps({"status": "success", "indexed_files": "auto"}))
@@ -116,7 +90,7 @@ async def sync_cmd(args):
 async def search_cmd(args):
     manager = get_manager(args.db, args.onnx)
     try:
-        results = await manager.search(args.query, limit=args.limit)
+        results = await run_search(manager, args.query, limit=args.limit)
 
         if args.json:
             output = []
@@ -150,14 +124,12 @@ async def search_cmd(args):
 async def api_cmd(args):
     manager = get_manager(args.db, args.onnx)
     try:
-        # Default to python if not specified
-        lang = args.lang or "python"
-        api_report = await manager.discovery.extract_api(args.library, language=lang)
+        report = await run_api(manager, args.library, lang=args.lang)
 
         if args.json:
-            print(json.dumps({"library": args.library, "report": api_report}))
+            print(json.dumps({"library": report.library, "report": report.report}))
         else:
-            print(api_report)
+            print(report.report)
     except Exception as e:
         logger.error("API discovery failed: %s", e)
         if args.json:
@@ -200,40 +172,33 @@ def config_cmd(args):
 async def setup_cmd(args):
     """Downloads necessary local models."""
     global_dir = get_global_dir()
-    model_dir = global_dir / "models" / "mini-lm"
-    model_dir.mkdir(parents=True, exist_ok=True)
-
-    files = {
-        "model.onnx": "https://huggingface.co/naranor/all-MiniLM-L6-v2-onnx/resolve/main/model.onnx",
-        "tokenizer.json": "https://huggingface.co/naranor/all-MiniLM-L6-v2-onnx/resolve/main/tokenizer.json",
-    }
 
     if not args.json:
         print(f"Setting up agent-coderag in {global_dir}...")
 
-    for name, url in files.items():
-        target_path = model_dir / name
-        if target_path.exists() and not args.force:
-            if not args.json:
-                print(f"  {name} already exists. Skipping.")
-            continue
-
-        if not args.json:
-            print(f"  Downloading {name}...")
-        tmp_path = target_path.with_suffix(".tmp")
-        try:
-            response = requests.get(url, stream=True, timeout=30)
-            response.raise_for_status()
-            with open(tmp_path, "wb") as f:
-                for chunk in response.iter_content(chunk_size=8192):
-                    f.write(chunk)
-            os.replace(tmp_path, target_path)
-        except Exception as e:
-            if tmp_path.exists():
-                tmp_path.unlink()
-            if not args.json:
-                print(f"  Error downloading {name}: {e}")
+    def _on_progress(event: str, name: str, error: Optional[BaseException]) -> None:
+        if args.json:
             return
+        if event == "skipped":
+            print(f"  {name} already exists. Skipping.")
+        elif event == "downloading":
+            print(f"  Downloading {name}...")
+        elif event == "error":
+            print(f"  Error downloading {name}: {error}")
+
+    try:
+        # Pass module-level requests.get so @patch("code_rag.entry.cli.requests.get")
+        # continues to intercept downloads in legacy CLI tests.
+        await run_setup(
+            force=args.force,
+            global_dir=global_dir,
+            on_progress=_on_progress,
+            http_get=requests.get,
+        )
+    except Exception:
+        # Legacy behaviour: per-file error already reported via on_progress;
+        # stop here without crashing or printing "Setup complete.".
+        return
 
     if not args.json:
         print("Setup complete.")
@@ -253,15 +218,16 @@ def get_manager(
     onnx_path: Optional[str] = None,
     allow_build_execution: bool = False,
 ) -> CodeRAGManager:
-    # 1. Setup Intelligence
+    """Wires a manager from the module-level components (legacy patch points).
+
+    Mirrors ``code_rag.services.factory.create_manager`` but resolves the
+    components through this module so existing CLI tests can substitute them.
+    """
     config = DistillerConfig.load()
     distiller = Distiller(config)
     embedder = Embedder(model_path=onnx_path)
 
-    # 2. Setup Storage
     storage = DuckDBStorage(db_path, embedder=embedder)
-
-    # 3. Setup Parser
     parser = MultiParser()
 
     return CodeRAGManager(

agent_coderag-1.3.3/code_rag/services/config.py

@@ -0,0 +1,25 @@
+from code_rag.intelligence.distiller import DistillerConfig
+
+
+def load_or_update_config(
+    url: str | None = None,
+    key: str | None = None,
+    model: str | None = None,
+    provider: str | None = None,
+) -> DistillerConfig:
+    """Loads the persisted config, optionally updating and saving it."""
+    config = DistillerConfig.load()
+    if not any([url, key, model, provider]):
+        return config
+
+    if url is not None:
+        config.api_base = url
+    if key is not None:
+        config.api_key = key
+    if model is not None:
+        config.model = model
+    if provider is not None:
+        config.provider = provider
+
+    config.save()
+    return config

agent_coderag-1.3.3/code_rag/services/discovery_api.py

@@ -0,0 +1,8 @@
+from code_rag.api.models import ApiReport
+
+
+async def run_api(manager, library: str, *, lang: str | None = None) -> ApiReport:
+    """Discovers and returns the public API report for a library."""
+    language = lang or "python"
+    report = await manager.discovery.extract_api(library, language=language)
+    return ApiReport(library=library, language=language, report=report)

agent_coderag-1.3.3/code_rag/services/factory.py

@@ -0,0 +1,28 @@
+from typing import Optional
+
+from code_rag.core.manager import CodeRAGManager
+from code_rag.intelligence.distiller import Distiller, DistillerConfig
+from code_rag.intelligence.embedder import Embedder
+from code_rag.parsers.multi_parser import MultiParser
+from code_rag.storage.duckdb_impl import DuckDBStorage
+
+
+def create_manager(
+    db_path: str,
+    onnx_path: Optional[str] = None,
+    allow_build_execution: bool = False,
+) -> CodeRAGManager:
+    """Builds a fully wired CodeRAGManager (storage, parser, distiller)."""
+    config = DistillerConfig.load()
+    distiller = Distiller(config)
+    embedder = Embedder(model_path=onnx_path)
+
+    storage = DuckDBStorage(db_path, embedder=embedder)
+    parser = MultiParser()
+
+    return CodeRAGManager(
+        storage,
+        parser,
+        distiller,
+        allow_build_execution=allow_build_execution,
+    )

agent_coderag-1.3.3/code_rag/services/search.py

@@ -0,0 +1,6 @@
+from code_rag.core.models import KnowledgeUnit
+
+
+async def run_search(manager, query: str, *, limit: int = 5) -> list[KnowledgeUnit]:
+    """Performs semantic search across indexed units."""
+    return await manager.search(query, limit=limit)

agent_coderag-1.3.3/code_rag/services/setup.py

@@ -0,0 +1,72 @@
+import os
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+import requests
+
+from code_rag.api.models import SetupResult
+from code_rag.intelligence.embedder import get_global_dir
+
+MODEL_FILES = {
+    "model.onnx": "https://huggingface.co/naranor/all-MiniLM-L6-v2-onnx/resolve/main/model.onnx",
+    "tokenizer.json": "https://huggingface.co/naranor/all-MiniLM-L6-v2-onnx/resolve/main/tokenizer.json",
+}
+
+HttpGet = Callable[..., Any]
+
+# Progress callback signature: (event, name, error) where event is one of
+# "downloading", "skipped", "error" and error is set only for "error".
+ProgressCallback = Callable[[str, str, Optional[BaseException]], None]
+
+
+def _download_file(get: HttpGet, url: str, target_path: Path) -> None:
+    tmp_path = target_path.with_suffix(".tmp")
+    try:
+        response = get(url, stream=True, timeout=30)
+        response.raise_for_status()
+        with open(tmp_path, "wb") as handle:
+            for chunk in response.iter_content(chunk_size=8192):
+                handle.write(chunk)
+        os.replace(tmp_path, target_path)
+    except Exception:
+        if tmp_path.exists():
+            tmp_path.unlink()
+        raise
+
+
+async def run_setup(
+    *,
+    force: bool = False,
+    global_dir: Optional[Path] = None,
+    on_progress: Optional[ProgressCallback] = None,
+    http_get: Optional[HttpGet] = None,
+) -> SetupResult:
+    """Downloads missing local embedding model files into the global dir."""
+    target_dir = global_dir if global_dir is not None else get_global_dir()
+    model_dir = target_dir / "models" / "mini-lm"
+    model_dir.mkdir(parents=True, exist_ok=True)
+    get: HttpGet = http_get or requests.get
+
+    downloaded: list[str] = []
+    skipped: list[str] = []
+
+    for name, url in MODEL_FILES.items():
+        target_path = model_dir / name
+        if target_path.exists() and not force:
+            skipped.append(name)
+            if on_progress:
+                on_progress("skipped", name, None)
+            continue
+
+        if on_progress:
+            on_progress("downloading", name, None)
+
+        try:
+            _download_file(get, url, target_path)
+            downloaded.append(name)
+        except Exception as exc:
+            if on_progress:
+                on_progress("error", name, exc)
+            raise
+
+    return SetupResult(model_dir=str(model_dir), downloaded=downloaded, skipped=skipped)