codexa 0.4.0__py3-none-any.whl

semantic_code_intelligence/tests/test_semantic_chunker.py

@@ -0,0 +1,255 @@
+"""Tests for the AST-aware semantic chunker."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from semantic_code_intelligence.indexing.semantic_chunker import (
+    SemanticChunk,
+    _build_semantic_label,
+    _extract_uncovered_blocks,
+    _symbols_to_chunks,
+    semantic_chunk_code,
+    semantic_chunk_file,
+)
+
+
+SAMPLE_PYTHON = """\
+import os
+import sys
+
+def hello(name):
+    \"\"\"Say hello.\"\"\"
+    return f"Hello, {name}!"
+
+class Greeter:
+    def __init__(self, prefix):
+        self.prefix = prefix
+
+    def greet(self, name):
+        return f"{self.prefix} {name}"
+
+x = 42
+"""
+
+SAMPLE_JS = """\
+const fs = require('fs');
+
+function add(a, b) {
+    return a + b;
+}
+
+class Calculator {
+    constructor() {
+        this.result = 0;
+    }
+    add(value) {
+        this.result += value;
+    }
+}
+"""
+
+
+# ---------------------------------------------------------------------------
+# SemanticChunk dataclass
+# ---------------------------------------------------------------------------
+
+class TestSemanticChunk:
+    def test_creation(self):
+        sc = SemanticChunk(
+            file_path="test.py",
+            content="def foo(): pass",
+            start_line=1,
+            end_line=1,
+            chunk_index=0,
+            language="python",
+            symbol_name="foo",
+            symbol_kind="function",
+        )
+        assert sc.symbol_name == "foo"
+        assert sc.symbol_kind == "function"
+
+    def test_to_dict(self):
+        sc = SemanticChunk(
+            file_path="test.py",
+            content="class Bar: pass",
+            start_line=1,
+            end_line=1,
+            chunk_index=0,
+            language="python",
+            symbol_name="Bar",
+            symbol_kind="class",
+            parameters=["x", "y"],
+        )
+        d = sc.to_dict()
+        assert d["symbol_name"] == "Bar"
+        assert d["symbol_kind"] == "class"
+        assert d["parameters"] == ["x", "y"]
+
+    def test_defaults(self):
+        sc = SemanticChunk(
+            file_path="t.py", content="x=1", start_line=1,
+            end_line=1, chunk_index=0, language="python",
+        )
+        assert sc.symbol_name == ""
+        assert sc.parent_symbol == ""
+        assert sc.parameters == []
+
+
+# ---------------------------------------------------------------------------
+# Semantic label builder
+# ---------------------------------------------------------------------------
+
+class TestBuildSemanticLabel:
+    def test_function(self):
+        sc = SemanticChunk(
+            file_path="t.py", content="", start_line=1, end_line=1,
+            chunk_index=0, language="python",
+            symbol_name="foo", symbol_kind="function", parameters=["x"],
+        )
+        label = _build_semantic_label(sc)
+        assert "[python]" in label
+        assert "function" in label
+        assert "foo" in label
+        assert "(x)" in label
+
+    def test_method_with_parent(self):
+        sc = SemanticChunk(
+            file_path="t.py", content="", start_line=1, end_line=1,
+            chunk_index=0, language="python",
+            symbol_name="greet", symbol_kind="method",
+            parent_symbol="Greeter",
+        )
+        label = _build_semantic_label(sc)
+        assert "Greeter.greet" in label
+
+    def test_empty_kind(self):
+        sc = SemanticChunk(
+            file_path="t.py", content="x=1", start_line=1, end_line=1,
+            chunk_index=0, language="python",
+        )
+        label = _build_semantic_label(sc)
+        assert "[python]" in label
+
+
+# ---------------------------------------------------------------------------
+# Uncovered blocks extraction
+# ---------------------------------------------------------------------------
+
+class TestExtractUncoveredBlocks:
+    def test_all_covered(self):
+        lines = ["a\n", "b\n", "c\n"]
+        covered = {1, 2, 3}
+        assert _extract_uncovered_blocks(lines, covered) == []
+
+    def test_none_covered(self):
+        lines = ["a\n", "b\n"]
+        blocks = _extract_uncovered_blocks(lines, set())
+        assert len(blocks) == 1
+        assert blocks[0][0] == 1  # start_line
+        assert blocks[0][1] == 2  # end_line
+
+    def test_gap_in_middle(self):
+        lines = ["a\n", "b\n", "c\n", "d\n", "e\n"]
+        covered = {1, 2, 5}
+        blocks = _extract_uncovered_blocks(lines, covered)
+        assert len(blocks) == 1
+        assert blocks[0][0] == 3
+        assert blocks[0][1] == 4
+
+    def test_multiple_gaps(self):
+        lines = [f"line{i}\n" for i in range(1, 8)]
+        covered = {2, 5}
+        blocks = _extract_uncovered_blocks(lines, covered)
+        assert len(blocks) == 3  # lines 1, 3-4, 6-7
+
+
+# ---------------------------------------------------------------------------
+# semantic_chunk_code
+# ---------------------------------------------------------------------------
+
+class TestSemanticChunkCode:
+    def test_empty_content(self):
+        result = semantic_chunk_code("", "test.py")
+        assert result == []
+
+    def test_whitespace_only(self):
+        result = semantic_chunk_code("   \n  ", "test.py")
+        assert result == []
+
+    def test_python_produces_chunks(self):
+        chunks = semantic_chunk_code(SAMPLE_PYTHON, "test.py")
+        assert len(chunks) > 0
+        assert all(isinstance(c, SemanticChunk) for c in chunks)
+
+    def test_python_has_function_chunks(self):
+        chunks = semantic_chunk_code(SAMPLE_PYTHON, "test.py")
+        func_chunks = [c for c in chunks if c.symbol_kind == "function"]
+        assert len(func_chunks) >= 1
+        names = [c.symbol_name for c in func_chunks]
+        assert "hello" in names
+
+    def test_python_has_class_chunks(self):
+        chunks = semantic_chunk_code(SAMPLE_PYTHON, "test.py")
+        class_chunks = [c for c in chunks if c.symbol_kind == "class"]
+        assert len(class_chunks) >= 1
+        assert any(c.symbol_name == "Greeter" for c in class_chunks)
+
+    def test_javascript_produces_chunks(self):
+        chunks = semantic_chunk_code(SAMPLE_JS, "test.js")
+        assert len(chunks) > 0
+
+    def test_unsupported_language_fallback(self):
+        code = "some random code\nanother line\n"
+        chunks = semantic_chunk_code(code, "test.xyz")
+        assert len(chunks) >= 1
+        # Fallback chunks are "block" kind
+        assert all(c.symbol_kind == "block" for c in chunks)
+
+    def test_chunk_indices_sequential(self):
+        chunks = semantic_chunk_code(SAMPLE_PYTHON, "test.py")
+        indices = [c.chunk_index for c in chunks]
+        assert indices == list(range(len(chunks)))
+
+    def test_chunks_have_content(self):
+        chunks = semantic_chunk_code(SAMPLE_PYTHON, "test.py")
+        for c in chunks:
+            assert c.content.strip() != ""
+
+    def test_large_function_gets_split(self):
+        # Generate a big function
+        big_body = "\n".join(f"    x{i} = {i}" for i in range(100))
+        code = f"def big_func():\n{big_body}\n"
+        chunks = semantic_chunk_code(code, "big.py", chunk_size=200)
+        func_chunks = [c for c in chunks if c.symbol_name == "big_func"]
+        assert len(func_chunks) > 1
+
+    def test_semantic_labels_populated(self):
+        chunks = semantic_chunk_code(SAMPLE_PYTHON, "test.py")
+        labeled = [c for c in chunks if c.semantic_label]
+        assert len(labeled) > 0
+
+
+# ---------------------------------------------------------------------------
+# semantic_chunk_file
+# ---------------------------------------------------------------------------
+
+class TestSemanticChunkFile:
+    def test_existing_file(self, tmp_path):
+        f = tmp_path / "sample.py"
+        f.write_text(SAMPLE_PYTHON, encoding="utf-8")
+        chunks = semantic_chunk_file(f)
+        assert len(chunks) > 0
+
+    def test_nonexistent_file(self, tmp_path):
+        f = tmp_path / "nope.py"
+        chunks = semantic_chunk_file(f)
+        assert chunks == []
+
+    def test_empty_file(self, tmp_path):
+        f = tmp_path / "empty.py"
+        f.write_text("", encoding="utf-8")
+        chunks = semantic_chunk_file(f)
+        assert chunks == []

semantic_code_intelligence/tests/test_tools.py

@@ -0,0 +1,182 @@
+"""Tests for the AI tool interaction layer."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from semantic_code_intelligence.tools import (
+    TOOL_DEFINITIONS,
+    ToolRegistry,
+    ToolResult,
+)
+
+
+SAMPLE_PYTHON = """\
+import os
+
+def greet(name):
+    return f"Hello, {name}!"
+
+class Service:
+    def __init__(self, url):
+        self.url = url
+
+    def call(self):
+        return os.getenv("API_KEY")
+"""
+
+
+# ---------------------------------------------------------------------------
+# ToolResult
+# ---------------------------------------------------------------------------
+
+class TestToolResult:
+    def test_success(self):
+        r = ToolResult(tool_name="test", success=True, data={"x": 1})
+        d = r.to_dict()
+        assert d["success"] is True
+        assert d["data"]["x"] == 1
+
+    def test_failure(self):
+        r = ToolResult(tool_name="test", success=False, error="boom")
+        d = r.to_dict()
+        assert d["success"] is False
+        assert d["error"] == "boom"
+
+    def test_to_json(self):
+        r = ToolResult(tool_name="test", success=True, data={})
+        j = r.to_json()
+        assert '"tool": "test"' in j
+        assert '"success": true' in j
+
+
+# ---------------------------------------------------------------------------
+# Tool Definitions
+# ---------------------------------------------------------------------------
+
+class TestToolDefinitions:
+    def test_definitions_exist(self):
+        assert len(TOOL_DEFINITIONS) > 0
+
+    def test_all_have_names(self):
+        for defn in TOOL_DEFINITIONS:
+            assert "name" in defn
+            assert "description" in defn
+
+    def test_known_tools(self):
+        names = {d["name"] for d in TOOL_DEFINITIONS}
+        assert "semantic_search" in names
+        assert "explain_symbol" in names
+        assert "summarize_repo" in names
+        assert "get_context" in names
+
+
+# ---------------------------------------------------------------------------
+# ToolRegistry
+# ---------------------------------------------------------------------------
+
+class TestToolRegistry:
+    def test_init(self, tmp_path):
+        registry = ToolRegistry(tmp_path)
+        assert registry.tool_definitions == TOOL_DEFINITIONS
+
+    def test_unknown_tool(self, tmp_path):
+        registry = ToolRegistry(tmp_path)
+        result = registry.invoke("nonexistent_tool")
+        assert result.success is False
+        assert "Unknown tool" in result.error
+
+    def test_explain_symbol_not_found(self, tmp_path):
+        registry = ToolRegistry(tmp_path)
+        result = registry.invoke("explain_symbol", symbol_name="NoSuchSymbol")
+        assert result.success is False
+
+    def test_index_and_explain_symbol(self, tmp_path):
+        f = tmp_path / "service.py"
+        f.write_text(SAMPLE_PYTHON, encoding="utf-8")
+
+        registry = ToolRegistry(tmp_path)
+        registry.index_file(str(f))
+
+        result = registry.invoke("explain_symbol", symbol_name="greet")
+        assert result.success is True
+        assert result.data["symbol_name"] == "greet"
+        assert len(result.data["explanations"]) >= 1
+
+    def test_explain_file(self, tmp_path):
+        f = tmp_path / "service.py"
+        f.write_text(SAMPLE_PYTHON, encoding="utf-8")
+
+        registry = ToolRegistry(tmp_path)
+        result = registry.invoke("explain_file", file_path=str(f))
+        assert result.success is True
+        assert len(result.data["symbols"]) >= 1
+
+    def test_summarize_repo(self, tmp_path):
+        f = tmp_path / "service.py"
+        f.write_text(SAMPLE_PYTHON, encoding="utf-8")
+
+        registry = ToolRegistry(tmp_path)
+        registry.index_file(str(f))
+
+        result = registry.invoke("summarize_repo")
+        assert result.success is True
+        assert "total_files" in result.data
+
+    def test_find_references(self, tmp_path):
+        f = tmp_path / "service.py"
+        f.write_text(SAMPLE_PYTHON, encoding="utf-8")
+
+        registry = ToolRegistry(tmp_path)
+        registry.index_file(str(f))
+
+        result = registry.invoke("find_references", symbol_name="greet")
+        assert result.success is True
+        assert result.data["reference_count"] >= 1
+
+    def test_get_dependencies(self, tmp_path):
+        f = tmp_path / "service.py"
+        f.write_text(SAMPLE_PYTHON, encoding="utf-8")
+
+        registry = ToolRegistry(tmp_path)
+        result = registry.invoke("get_dependencies", file_path=str(f))
+        assert result.success is True
+
+    def test_get_call_graph(self, tmp_path):
+        f = tmp_path / "service.py"
+        f.write_text(SAMPLE_PYTHON, encoding="utf-8")
+
+        registry = ToolRegistry(tmp_path)
+        registry.index_file(str(f))
+
+        result = registry.invoke("get_call_graph", symbol_name="greet")
+        assert result.success is True
+        assert "callers" in result.data
+        assert "callees" in result.data
+
+    def test_get_context_found(self, tmp_path):
+        f = tmp_path / "service.py"
+        f.write_text(SAMPLE_PYTHON, encoding="utf-8")
+
+        registry = ToolRegistry(tmp_path)
+        registry.index_file(str(f))
+
+        result = registry.invoke("get_context", symbol_name="Service")
+        assert result.success is True
+
+    def test_get_context_not_found(self, tmp_path):
+        registry = ToolRegistry(tmp_path)
+        result = registry.invoke("get_context", symbol_name="Missing")
+        assert result.success is False
+
+    def test_index_directory(self, tmp_path):
+        (tmp_path / ".codexa").mkdir()
+        (tmp_path / ".codexa" / "config.json").write_text("{}", encoding="utf-8")
+        (tmp_path / "a.py").write_text("x = 1\n", encoding="utf-8")
+        (tmp_path / "b.py").write_text("y = 2\n", encoding="utf-8")
+
+        registry = ToolRegistry(tmp_path)
+        count = registry.index_directory()
+        assert count >= 2

semantic_code_intelligence/tests/test_vector_store.py

@@ -0,0 +1,151 @@
+"""Tests for the vector store."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from semantic_code_intelligence.storage.vector_store import (
+    ChunkMetadata,
+    VectorStore,
+)
+
+
+def _make_metadata(n: int) -> list[ChunkMetadata]:
+    """Create n dummy metadata entries."""
+    return [
+        ChunkMetadata(
+            file_path=f"file_{i}.py",
+            start_line=1,
+            end_line=10,
+            chunk_index=i,
+            language="python",
+            content=f"content_{i}",
+        )
+        for i in range(n)
+    ]
+
+
+def _random_embeddings(n: int, dim: int = 128) -> np.ndarray:
+    """Create n random normalized embeddings."""
+    vecs = np.random.randn(n, dim).astype(np.float32)
+    norms = np.linalg.norm(vecs, axis=1, keepdims=True)
+    return vecs / norms
+
+
+class TestVectorStore:
+    """Tests for VectorStore operations."""
+
+    def test_create_empty(self):
+        store = VectorStore(128)
+        assert store.size == 0
+        assert store.dimension == 128
+
+    def test_add_and_size(self):
+        store = VectorStore(128)
+        emb = _random_embeddings(5)
+        meta = _make_metadata(5)
+        store.add(emb, meta)
+        assert store.size == 5
+
+    def test_add_mismatched_raises(self):
+        store = VectorStore(128)
+        emb = _random_embeddings(3)
+        meta = _make_metadata(5)
+        with pytest.raises(ValueError):
+            store.add(emb, meta)
+
+    def test_add_empty(self):
+        store = VectorStore(128)
+        store.add(np.array([], dtype=np.float32).reshape(0, 128), [])
+        assert store.size == 0
+
+    def test_search_returns_results(self):
+        store = VectorStore(128)
+        emb = _random_embeddings(10)
+        meta = _make_metadata(10)
+        store.add(emb, meta)
+
+        results = store.search(emb[0], top_k=3)
+        assert len(results) == 3
+        # First result should be the query itself (highest similarity)
+        assert results[0][0].file_path == "file_0.py"
+        assert results[0][1] > 0.99  # self-similarity ≈ 1.0
+
+    def test_search_empty_store(self):
+        store = VectorStore(128)
+        query = _random_embeddings(1)[0]
+        results = store.search(query, top_k=5)
+        assert results == []
+
+    def test_search_top_k_larger_than_store(self):
+        store = VectorStore(128)
+        emb = _random_embeddings(3)
+        meta = _make_metadata(3)
+        store.add(emb, meta)
+        results = store.search(emb[0], top_k=100)
+        assert len(results) == 3
+
+    def test_search_scores_descending(self):
+        store = VectorStore(128)
+        emb = _random_embeddings(20)
+        meta = _make_metadata(20)
+        store.add(emb, meta)
+
+        results = store.search(emb[0], top_k=10)
+        scores = [r[1] for r in results]
+        assert scores == sorted(scores, reverse=True)
+
+
+class TestVectorStorePersistence:
+    """Tests for save/load functionality."""
+
+    def test_save_creates_files(self, tmp_path: Path):
+        store = VectorStore(128)
+        emb = _random_embeddings(5)
+        meta = _make_metadata(5)
+        store.add(emb, meta)
+        store.save(tmp_path / "index")
+
+        assert (tmp_path / "index" / "vectors.faiss").exists()
+        assert (tmp_path / "index" / "metadata.json").exists()
+
+    def test_load_roundtrip(self, tmp_path: Path):
+        store = VectorStore(128)
+        emb = _random_embeddings(5)
+        meta = _make_metadata(5)
+        store.add(emb, meta)
+        store.save(tmp_path / "index")
+
+        loaded = VectorStore.load(tmp_path / "index")
+        assert loaded.size == 5
+        assert loaded.dimension == 128
+        assert len(loaded.metadata) == 5
+        assert loaded.metadata[0].file_path == "file_0.py"
+
+    def test_load_nonexistent_raises(self, tmp_path: Path):
+        with pytest.raises(FileNotFoundError):
+            VectorStore.load(tmp_path / "nonexistent")
+
+    def test_search_after_load(self, tmp_path: Path):
+        store = VectorStore(128)
+        emb = _random_embeddings(10)
+        meta = _make_metadata(10)
+        store.add(emb, meta)
+        store.save(tmp_path / "index")
+
+        loaded = VectorStore.load(tmp_path / "index")
+        results = loaded.search(emb[0], top_k=3)
+        assert len(results) == 3
+        assert results[0][0].file_path == "file_0.py"
+
+    def test_clear(self):
+        store = VectorStore(128)
+        emb = _random_embeddings(5)
+        meta = _make_metadata(5)
+        store.add(emb, meta)
+        store.clear()
+        assert store.size == 0
+        assert store.metadata == []