trelix-langchain 0.5.0__tar.gz

trelix_langchain-0.5.0/.gitignore

@@ -0,0 +1,58 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.egg-info/
+*.egg
+build/
+.eggs/
+pip-wheel-metadata/
+
+# dist/ — ignore generated packaging artefacts; binaries are attached via GitHub Releases.
+dist/
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+
+# Trelix index data — never commit these
+.trelix/
+
+# Test / coverage artefacts
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# Ruff / Mypy caches
+.ruff_cache/
+.mypy_cache/
+
+# Environment files — secrets must not be committed
+.env
+.env.local
+.env.*.local
+
+# Claude Code internal data
+.claude/
+
+# uv lockfile (not committed — project uses pip/hatchling)
+uv.lock
+
+# Editor / OS
+.DS_Store
+.idea/
+.vscode/
+*.swp
+*.swo
+Thumbs.db
+
+# Distribution / packaging
+*.tar.gz
+*.whl
+MANIFEST
+.superpowers/

trelix_langchain-0.5.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Trelix Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

trelix_langchain-0.5.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: trelix-langchain
+Version: 0.5.0
+Summary: LangChain retriever for trelix code intelligence
+Project-URL: Homepage, https://github.com/sairam0424/trelix
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: langchain-core>=0.1.0
+Requires-Dist: trelix>=0.4.0

trelix_langchain-0.5.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/trelix_langchain"]
+
+[project]
+name = "trelix-langchain"
+version = "0.5.0"
+description = "LangChain retriever for trelix code intelligence"
+requires-python = ">=3.11"
+dependencies = ["trelix>=0.4.0", "langchain-core>=0.1.0"]
+
+[project.urls]
+Homepage = "https://github.com/sairam0424/trelix"

trelix_langchain-0.5.0/src/trelix_langchain/__init__.py

@@ -0,0 +1,4 @@
+from trelix_langchain.retriever import TrelixRetriever
+
+__all__ = ["TrelixRetriever"]
+__version__ = "0.5.0"

trelix_langchain-0.5.0/src/trelix_langchain/retriever.py

@@ -0,0 +1,49 @@
+from langchain_core.callbacks import CallbackManagerForRetrieverRun
+from langchain_core.documents import Document
+from langchain_core.retrievers import BaseRetriever
+
+
+class TrelixRetriever(BaseRetriever):
+    repo_path: str
+    provider: str = "local"
+    k: int = 10
+
+    def _get_trelix_retriever(self):
+        from typing import Literal, cast
+
+        from trelix.core.config import EmbedderConfig, IndexConfig
+        from trelix.retrieval.retriever import Retriever
+
+        config = IndexConfig(
+            repo_path=self.repo_path,
+            embedder=EmbedderConfig(
+                provider=cast(
+                    Literal["openai", "azure", "local", "voyage", "local-code"],
+                    self.provider,
+                )
+            ),
+        )
+        return Retriever(config)
+
+    def _get_relevant_documents(
+        self,
+        query: str,
+        *,
+        run_manager: CallbackManagerForRetrieverRun,
+    ) -> list[Document]:
+        ctx = self._get_trelix_retriever().retrieve(query)
+        return [
+            Document(
+                page_content=r.symbol.body,
+                metadata={
+                    "source": r.file.rel_path,
+                    "symbol": r.symbol.qualified_name,
+                    "language": r.file.language.value,
+                    "kind": r.symbol.kind.value,
+                    "lines": str(r.symbol.line_start) + "-" + str(r.symbol.line_end),
+                    "score": r.score,
+                    "retrieval_source": r.source,
+                },
+            )
+            for r in ctx.results[: self.k]
+        ]

trelix_langchain-0.5.0/tests/test_retriever.py

@@ -0,0 +1,218 @@
+"""
+Tests for TrelixRetriever.
+
+Strategy:
+- Import / subclass checks run without any trelix index on disk.
+- Functional tests mock out trelix internals so they stay fast and hermetic.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from unittest.mock import MagicMock
+
+import pytest
+from langchain_core.documents import Document
+from langchain_core.retrievers import BaseRetriever
+from trelix_langchain import TrelixRetriever
+
+# ---------------------------------------------------------------------------
+# Helpers — minimal stubs that mimic trelix data-model shapes
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class _Language:
+    value: str = "python"
+
+
+@dataclass
+class _SymbolKind:
+    value: str = "function"
+
+
+@dataclass
+class _Symbol:
+    body: str = "def hello(): pass"
+    qualified_name: str = "mymodule.hello"
+    kind: _SymbolKind = field(default_factory=_SymbolKind)
+    line_start: int = 1
+    line_end: int = 3
+
+
+@dataclass
+class _File:
+    rel_path: str = "src/mymodule.py"
+    language: _Language = field(default_factory=_Language)
+
+
+@dataclass
+class _SearchResult:
+    symbol: _Symbol = field(default_factory=_Symbol)
+    file: _File = field(default_factory=_File)
+    score: float = 0.95
+    source: str = "vector"
+
+
+@dataclass
+class _RetrievedContext:
+    results: list
+
+
+def _make_context(n: int = 3) -> _RetrievedContext:
+    """Return a fake RetrievedContext with *n* results."""
+    return _RetrievedContext(results=[_SearchResult() for _ in range(n)])
+
+
+# ---------------------------------------------------------------------------
+# 1. Importability
+# ---------------------------------------------------------------------------
+
+
+def test_import_trelix_retriever():
+    """TrelixRetriever must be importable from the package root."""
+    from trelix_langchain import TrelixRetriever as TR  # noqa: F401
+
+    assert TR is TrelixRetriever
+
+
+def test_version_exposed():
+    import trelix_langchain
+
+    assert hasattr(trelix_langchain, "__version__")
+    assert trelix_langchain.__version__ == "0.4.0"
+
+
+# ---------------------------------------------------------------------------
+# 2. BaseRetriever subclass
+# ---------------------------------------------------------------------------
+
+
+def test_is_base_retriever_subclass():
+    assert issubclass(TrelixRetriever, BaseRetriever)
+
+
+def test_instantiation_sets_fields():
+    r = TrelixRetriever(repo_path="/tmp/repo", provider="openai", k=5)
+    assert r.repo_path == "/tmp/repo"
+    assert r.provider == "openai"
+    assert r.k == 5
+
+
+def test_default_field_values():
+    r = TrelixRetriever(repo_path="/tmp/repo")
+    assert r.provider == "local"
+    assert r.k == 10
+
+
+# ---------------------------------------------------------------------------
+# 3. invoke() / _get_relevant_documents() returns Documents with correct metadata
+# ---------------------------------------------------------------------------
+
+
+def _make_retriever_with_mock(k: int = 10, n_results: int = 3) -> TrelixRetriever:
+    """Return a TrelixRetriever whose internal trelix retriever is mocked."""
+    tr = TrelixRetriever(repo_path="/tmp/fake-repo", k=k)
+    mock_inner = MagicMock()
+    mock_inner.retrieve.return_value = _make_context(n_results)
+    tr._get_trelix_retriever = lambda: mock_inner  # type: ignore[method-assign]
+    return tr
+
+
+def test_invoke_returns_list_of_documents():
+    tr = _make_retriever_with_mock()
+    docs = tr.invoke("find hello function")
+    assert isinstance(docs, list)
+    assert len(docs) == 3
+    assert all(isinstance(d, Document) for d in docs)
+
+
+def test_document_page_content_is_symbol_body():
+    tr = _make_retriever_with_mock()
+    docs = tr.invoke("hello")
+    assert docs[0].page_content == "def hello(): pass"
+
+
+def test_document_metadata_source():
+    tr = _make_retriever_with_mock()
+    docs = tr.invoke("hello")
+    assert docs[0].metadata["source"] == "src/mymodule.py"
+
+
+def test_document_metadata_symbol():
+    tr = _make_retriever_with_mock()
+    docs = tr.invoke("hello")
+    assert docs[0].metadata["symbol"] == "mymodule.hello"
+
+
+def test_document_metadata_language():
+    tr = _make_retriever_with_mock()
+    docs = tr.invoke("hello")
+    assert docs[0].metadata["language"] == "python"
+
+
+def test_document_metadata_kind():
+    tr = _make_retriever_with_mock()
+    docs = tr.invoke("hello")
+    assert docs[0].metadata["kind"] == "function"
+
+
+def test_document_metadata_lines():
+    tr = _make_retriever_with_mock()
+    docs = tr.invoke("hello")
+    assert docs[0].metadata["lines"] == "1-3"
+
+
+def test_document_metadata_score():
+    tr = _make_retriever_with_mock()
+    docs = tr.invoke("hello")
+    assert docs[0].metadata["score"] == pytest.approx(0.95)
+
+
+def test_document_metadata_retrieval_source():
+    tr = _make_retriever_with_mock()
+    docs = tr.invoke("hello")
+    assert docs[0].metadata["retrieval_source"] == "vector"
+
+
+# ---------------------------------------------------------------------------
+# 4. k limits number of returned documents
+# ---------------------------------------------------------------------------
+
+
+def test_k_limits_results_when_fewer_available():
+    """k=5, but only 3 results available — should return 3."""
+    tr = _make_retriever_with_mock(k=5, n_results=3)
+    docs = tr.invoke("query")
+    assert len(docs) == 3
+
+
+def test_k_limits_results_when_more_available():
+    """k=2, 5 results available — should return exactly 2."""
+    tr = _make_retriever_with_mock(k=2, n_results=5)
+    docs = tr.invoke("query")
+    assert len(docs) == 2
+
+
+def test_k_equals_zero_returns_empty():
+    tr = _make_retriever_with_mock(k=0, n_results=5)
+    docs = tr.invoke("query")
+    assert docs == []
+
+
+def test_k_default_ten_limits_large_result_set():
+    """Default k=10: 15 results available — should cap at 10."""
+    tr = _make_retriever_with_mock(k=10, n_results=15)
+    docs = tr.invoke("query")
+    assert len(docs) == 10
+
+
+# ---------------------------------------------------------------------------
+# 5. Empty results
+# ---------------------------------------------------------------------------
+
+
+def test_empty_results_returns_empty_list():
+    tr = _make_retriever_with_mock(k=10, n_results=0)
+    docs = tr.invoke("nothing here")
+    assert docs == []