codexa 0.4.0__py3-none-any.whl

semantic_code_intelligence/tests/test_config.py

@@ -0,0 +1,154 @@
+"""Tests for config/settings module."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from semantic_code_intelligence.config.settings import (
+    AppConfig,
+    DEFAULT_EXTENSIONS,
+    DEFAULT_IGNORE_DIRS,
+    EmbeddingConfig,
+    IndexConfig,
+    SearchConfig,
+    init_project,
+    load_config,
+    save_config,
+)
+
+
+class TestDefaultConfigs:
+    """Tests for default configuration values."""
+
+    def test_embedding_config_defaults(self):
+        cfg = EmbeddingConfig()
+        assert cfg.model_name == "all-MiniLM-L6-v2"
+        assert cfg.chunk_size == 512
+        assert cfg.chunk_overlap == 64
+
+    def test_search_config_defaults(self):
+        cfg = SearchConfig()
+        assert cfg.top_k == 10
+        assert cfg.similarity_threshold == 0.3
+
+    def test_index_config_defaults(self):
+        cfg = IndexConfig()
+        assert cfg.ignore_dirs == DEFAULT_IGNORE_DIRS
+        assert cfg.extensions == DEFAULT_EXTENSIONS
+        assert cfg.use_incremental is True
+
+    def test_app_config_defaults(self):
+        cfg = AppConfig()
+        assert cfg.verbose is False
+        assert isinstance(cfg.embedding, EmbeddingConfig)
+        assert isinstance(cfg.search, SearchConfig)
+        assert isinstance(cfg.index, IndexConfig)
+
+
+class TestConfigPaths:
+    """Tests for config path resolution."""
+
+    def test_config_dir(self, tmp_path: Path):
+        config_dir = AppConfig.config_dir(tmp_path)
+        assert config_dir == tmp_path / ".codexa"
+
+    def test_config_path(self, tmp_path: Path):
+        config_path = AppConfig.config_path(tmp_path)
+        assert config_path == tmp_path / ".codexa" / "config.json"
+
+    def test_index_dir(self, tmp_path: Path):
+        index_dir = AppConfig.index_dir(tmp_path)
+        assert index_dir == tmp_path / ".codexa" / "index"
+
+
+class TestLoadConfig:
+    """Tests for loading config from disk."""
+
+    def test_load_config_no_file_returns_defaults(self, tmp_path: Path):
+        cfg = load_config(tmp_path)
+        assert cfg.project_root == str(tmp_path.resolve())
+        assert cfg.embedding.model_name == "all-MiniLM-L6-v2"
+
+    def test_load_config_from_file(self, tmp_path: Path):
+        config_dir = tmp_path / ".codexa"
+        config_dir.mkdir()
+        config_data = {
+            "project_root": str(tmp_path),
+            "verbose": True,
+            "embedding": {"model_name": "custom-model", "chunk_size": 256},
+            "search": {"top_k": 5},
+            "index": {"use_incremental": False},
+        }
+        (config_dir / "config.json").write_text(
+            json.dumps(config_data), encoding="utf-8"
+        )
+
+        cfg = load_config(tmp_path)
+        assert cfg.verbose is True
+        assert cfg.embedding.model_name == "custom-model"
+        assert cfg.embedding.chunk_size == 256
+        assert cfg.search.top_k == 5
+        assert cfg.index.use_incremental is False
+
+
+class TestSaveConfig:
+    """Tests for saving config to disk."""
+
+    def test_save_config_creates_file(self, tmp_path: Path):
+        cfg = AppConfig(project_root=str(tmp_path))
+        config_path = save_config(cfg, tmp_path)
+
+        assert config_path.exists()
+        data = json.loads(config_path.read_text(encoding="utf-8"))
+        assert data["project_root"] == str(tmp_path)
+
+    def test_save_config_creates_directory(self, tmp_path: Path):
+        cfg = AppConfig(project_root=str(tmp_path))
+        save_config(cfg, tmp_path)
+
+        assert (tmp_path / ".codexa").is_dir()
+
+
+class TestInitProject:
+    """Tests for project initialization."""
+
+    def test_init_creates_config_dir(self, tmp_path: Path):
+        config, config_path = init_project(tmp_path)
+        assert (tmp_path / ".codexa").is_dir()
+
+    def test_init_creates_index_dir(self, tmp_path: Path):
+        config, config_path = init_project(tmp_path)
+        assert (tmp_path / ".codexa" / "index").is_dir()
+
+    def test_init_creates_config_file(self, tmp_path: Path):
+        config, config_path = init_project(tmp_path)
+        assert config_path.exists()
+        assert config_path.name == "config.json"
+
+    def test_init_returns_valid_config(self, tmp_path: Path):
+        config, _ = init_project(tmp_path)
+        assert config.project_root == str(tmp_path.resolve())
+        assert isinstance(config, AppConfig)
+
+    def test_init_config_is_loadable(self, tmp_path: Path):
+        init_project(tmp_path)
+        loaded = load_config(tmp_path)
+        assert loaded.project_root == str(tmp_path.resolve())
+
+
+class TestDefaultIgnoreDirs:
+    """Tests for default ignore directories."""
+
+    def test_common_dirs_ignored(self):
+        for dirname in [".git", "node_modules", "build", "dist", "venv", "__pycache__"]:
+            assert dirname in DEFAULT_IGNORE_DIRS
+
+    def test_default_extensions_include_python(self):
+        assert ".py" in DEFAULT_EXTENSIONS
+
+    def test_default_extensions_include_common_languages(self):
+        for ext in [".js", ".ts", ".java", ".go", ".rs", ".cpp"]:
+            assert ext in DEFAULT_EXTENSIONS

semantic_code_intelligence/tests/test_context.py

@@ -0,0 +1,381 @@
+"""Tests for the context engine — ContextBuilder, CallGraph, DependencyMap."""
+
+import pytest
+
+from semantic_code_intelligence.context.engine import (
+    CallGraph,
+    ContextBuilder,
+    ContextWindow,
+    DependencyMap,
+    FileDependency,
+)
+from semantic_code_intelligence.parsing.parser import Symbol
+
+
+# ---------------------------------------------------------------------------
+# Sample code
+# ---------------------------------------------------------------------------
+
+PYTHON_SAMPLE = '''\
+import os
+from pathlib import Path
+
+def helper():
+    return 42
+
+def main():
+    result = helper()
+    print(result)
+
+class Worker:
+    def __init__(self):
+        self.data = []
+
+    def process(self):
+        result = helper()
+        return result
+'''
+
+JS_SAMPLE = '''\
+import { readFile } from 'fs';
+
+function parse(data) {
+    return JSON.parse(data);
+}
+
+function load(path) {
+    const data = readFile(path);
+    return parse(data);
+}
+
+class DataLoader {
+    constructor(path) {
+        this.path = path;
+    }
+
+    load() {
+        return load(this.path);
+    }
+}
+'''
+
+
+# ---------------------------------------------------------------------------
+# ContextBuilder
+# ---------------------------------------------------------------------------
+
+class TestContextBuilder:
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        self.builder = ContextBuilder()
+        self.builder.index_file("app.py", PYTHON_SAMPLE)
+
+    def test_index_file_returns_symbols(self):
+        symbols = self.builder.get_symbols("app.py")
+        assert len(symbols) > 0
+
+    def test_get_all_symbols(self):
+        self.builder.index_file("app.js", JS_SAMPLE)
+        all_syms = self.builder.get_all_symbols()
+        assert len(all_syms) > 5  # should have symbols from both files
+
+    def test_find_symbol_by_name(self):
+        results = self.builder.find_symbol("helper")
+        assert len(results) >= 1
+        assert results[0].name == "helper"
+
+    def test_find_symbol_by_name_and_kind(self):
+        results = self.builder.find_symbol("Worker", kind="class")
+        assert len(results) == 1
+        assert results[0].kind == "class"
+
+    def test_find_symbol_not_found(self):
+        results = self.builder.find_symbol("nonexistent")
+        assert results == []
+
+    def test_build_context(self):
+        symbols = self.builder.get_symbols("app.py")
+        main_sym = next(s for s in symbols if s.name == "main")
+        ctx = self.builder.build_context(main_sym)
+        assert isinstance(ctx, ContextWindow)
+        assert ctx.focal_symbol.name == "main"
+
+    def test_context_has_imports(self):
+        symbols = self.builder.get_symbols("app.py")
+        main_sym = next(s for s in symbols if s.name == "main")
+        ctx = self.builder.build_context(main_sym)
+        assert len(ctx.imports) >= 2
+
+    def test_context_has_related_symbols(self):
+        symbols = self.builder.get_symbols("app.py")
+        main_sym = next(s for s in symbols if s.name == "main")
+        ctx = self.builder.build_context(main_sym)
+        related_names = {s.name for s in ctx.related_symbols}
+        assert "helper" in related_names
+
+    def test_context_to_dict(self):
+        symbols = self.builder.get_symbols("app.py")
+        main_sym = next(s for s in symbols if s.name == "main")
+        ctx = self.builder.build_context(main_sym)
+        d = ctx.to_dict()
+        assert "focal_symbol" in d
+        assert "related_symbols" in d
+        assert "imports" in d
+        assert d["focal_symbol"]["name"] == "main"
+
+    def test_context_render(self):
+        symbols = self.builder.get_symbols("app.py")
+        main_sym = next(s for s in symbols if s.name == "main")
+        ctx = self.builder.build_context(main_sym)
+        text = ctx.render()
+        assert "main" in text
+        assert "File:" in text
+        assert "Lines:" in text
+
+    def test_context_render_with_max_lines(self):
+        symbols = self.builder.get_symbols("app.py")
+        main_sym = next(s for s in symbols if s.name == "main")
+        ctx = self.builder.build_context(main_sym)
+        text = ctx.render(max_lines=1)
+        assert "main" in text
+
+    def test_build_context_for_name(self):
+        contexts = self.builder.build_context_for_name("helper")
+        assert len(contexts) >= 1
+        assert contexts[0].focal_symbol.name == "helper"
+
+    def test_build_context_for_name_not_found(self):
+        contexts = self.builder.build_context_for_name("nonexistent")
+        assert contexts == []
+
+    def test_get_symbols_unknown_file(self):
+        assert self.builder.get_symbols("unknown.py") == []
+
+    def test_index_multiple_files(self):
+        self.builder.index_file("app.js", JS_SAMPLE)
+        py_symbols = self.builder.get_symbols("app.py")
+        js_symbols = self.builder.get_symbols("app.js")
+        assert len(py_symbols) > 0
+        assert len(js_symbols) > 0
+
+
+# ---------------------------------------------------------------------------
+# CallGraph
+# ---------------------------------------------------------------------------
+
+class TestCallGraph:
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        self.builder = ContextBuilder()
+        self.builder.index_file("app.py", PYTHON_SAMPLE)
+        self.symbols = self.builder.get_all_symbols()
+        self.graph = CallGraph()
+        self.graph.build(self.symbols)
+
+    def test_edges_found(self):
+        assert len(self.graph.edges) > 0
+
+    def test_main_calls_helper(self):
+        callers = self.graph.callers_of("helper")
+        caller_names = {e.caller for e in callers}
+        assert any("main" in c for c in caller_names)
+
+    def test_process_calls_helper(self):
+        callers = self.graph.callers_of("helper")
+        caller_names = {e.caller for e in callers}
+        assert any("process" in c for c in caller_names)
+
+    def test_callees_of_main(self):
+        callees = self.graph.callees_of("app.py:main")
+        callee_names = {e.callee for e in callees}
+        assert "helper" in callee_names
+
+    def test_no_self_references(self):
+        for edge in self.graph.edges:
+            # Caller key includes file path, callee is just name
+            assert edge.callee not in edge.caller or edge.callee != edge.caller.split(":")[-1]
+
+    def test_callers_of_unknown(self):
+        assert self.graph.callers_of("nonexistent") == []
+
+    def test_callees_of_unknown(self):
+        assert self.graph.callees_of("nonexistent") == []
+
+    def test_to_dict(self):
+        d = self.graph.to_dict()
+        assert "edges" in d
+        assert "node_count" in d
+        assert "edge_count" in d
+        assert d["edge_count"] == len(self.graph.edges)
+
+    def test_build_clears_previous(self):
+        """Build should reset the graph."""
+        initial_count = len(self.graph.edges)
+        self.graph.build([])  # rebuild with no symbols
+        assert len(self.graph.edges) == 0
+
+    def test_edge_to_dict(self):
+        if self.graph.edges:
+            d = self.graph.edges[0].to_dict()
+            assert "caller" in d
+            assert "callee" in d
+            assert "file_path" in d
+            assert "line" in d
+
+    def test_js_call_graph(self):
+        builder = ContextBuilder()
+        builder.index_file("app.js", JS_SAMPLE)
+        symbols = builder.get_all_symbols()
+        graph = CallGraph()
+        graph.build(symbols)
+        callers = graph.callers_of("parse")
+        assert any("load" in e.caller for e in callers)
+
+
+# ---------------------------------------------------------------------------
+# DependencyMap
+# ---------------------------------------------------------------------------
+
+class TestDependencyMap:
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        self.dep_map = DependencyMap()
+
+    def test_add_python_file(self):
+        deps = self.dep_map.add_file("app.py", PYTHON_SAMPLE)
+        assert len(deps) >= 2  # import os, from pathlib import Path
+
+    def test_add_js_file(self):
+        deps = self.dep_map.add_file("app.js", JS_SAMPLE)
+        assert len(deps) >= 1
+
+    def test_get_dependencies(self):
+        self.dep_map.add_file("app.py", PYTHON_SAMPLE)
+        deps = self.dep_map.get_dependencies("app.py")
+        assert len(deps) >= 2
+
+    def test_get_dependencies_unknown(self):
+        assert self.dep_map.get_dependencies("unknown.py") == []
+
+    def test_get_all_files(self):
+        self.dep_map.add_file("app.py", PYTHON_SAMPLE)
+        self.dep_map.add_file("app.js", JS_SAMPLE)
+        files = self.dep_map.get_all_files()
+        assert "app.py" in files
+        assert "app.js" in files
+
+    def test_get_dependents(self):
+        self.dep_map.add_file("app.py", PYTHON_SAMPLE)
+        dependents = self.dep_map.get_dependents("os")
+        assert len(dependents) >= 1
+        assert dependents[0].source_file == "app.py"
+
+    def test_get_dependents_pathlib(self):
+        self.dep_map.add_file("app.py", PYTHON_SAMPLE)
+        dependents = self.dep_map.get_dependents("pathlib")
+        assert len(dependents) >= 1
+
+    def test_get_dependents_not_found(self):
+        self.dep_map.add_file("app.py", PYTHON_SAMPLE)
+        assert self.dep_map.get_dependents("nonexistent_module") == []
+
+    def test_dependency_to_dict(self):
+        deps = self.dep_map.add_file("app.py", PYTHON_SAMPLE)
+        if deps:
+            d = deps[0].to_dict()
+            assert "source_file" in d
+            assert "import_text" in d
+            assert "line" in d
+
+    def test_to_dict(self):
+        self.dep_map.add_file("app.py", PYTHON_SAMPLE)
+        d = self.dep_map.to_dict()
+        assert "app.py" in d
+        assert isinstance(d["app.py"], list)
+
+    def test_dependency_line_numbers(self):
+        deps = self.dep_map.add_file("app.py", PYTHON_SAMPLE)
+        lines = [d.line for d in deps]
+        assert 1 in lines  # 'import os' is line 1
+        assert 2 in lines  # 'from pathlib...' is line 2
+
+
+# ---------------------------------------------------------------------------
+# Edge cases
+# ---------------------------------------------------------------------------
+
+class TestContextEdgeCases:
+    def test_builder_nonexistent_file(self, tmp_path):
+        builder = ContextBuilder()
+        syms = builder.index_file(str(tmp_path / "nope.py"))
+        assert syms == []
+
+    def test_builder_empty_content(self):
+        builder = ContextBuilder()
+        syms = builder.index_file("empty.py", "")
+        assert syms == []
+
+    def test_builder_unsupported_extension(self):
+        builder = ContextBuilder()
+        syms = builder.index_file("style.css", "body { color: red; }")
+        assert syms == []
+
+    def test_call_graph_empty(self):
+        graph = CallGraph()
+        graph.build([])
+        assert graph.edges == []
+
+    def test_dep_map_empty_file(self):
+        dep_map = DependencyMap()
+        deps = dep_map.add_file("empty.py", "")
+        assert deps == []
+
+    def test_dep_map_unsupported_extension(self):
+        dep_map = DependencyMap()
+        deps = dep_map.add_file("style.css", "body { color: red; }")
+        assert deps == []
+
+
+# ---------------------------------------------------------------------------
+# Integration: builder -> call graph -> dependency map
+# ---------------------------------------------------------------------------
+
+class TestContextIntegration:
+    def test_full_pipeline(self):
+        builder = ContextBuilder()
+        builder.index_file("app.py", PYTHON_SAMPLE)
+        builder.index_file("app.js", JS_SAMPLE)
+
+        # Build call graph from all symbols
+        all_symbols = builder.get_all_symbols()
+        graph = CallGraph()
+        graph.build(all_symbols)
+        assert len(graph.edges) > 0
+
+        # Build dependency map
+        dep_map = DependencyMap()
+        dep_map.add_file("app.py", PYTHON_SAMPLE)
+        dep_map.add_file("app.js", JS_SAMPLE)
+        assert len(dep_map.get_all_files()) == 2
+
+        # Build context for a symbol
+        helpers = builder.find_symbol("helper")
+        assert len(helpers) >= 1
+        ctx = builder.build_context(helpers[0])
+        assert ctx.focal_symbol.name == "helper"
+        assert len(ctx.imports) >= 2
+
+    def test_cross_file_symbol_search(self):
+        builder = ContextBuilder()
+        builder.index_file("app.py", PYTHON_SAMPLE)
+        builder.index_file("app.js", JS_SAMPLE)
+
+        # "parse" exists in the JS file
+        results = builder.find_symbol("parse")
+        assert len(results) >= 1
+        assert any(r.file_path == "app.js" for r in results)
+
+        # "helper" exists in the Python file
+        results = builder.find_symbol("helper")
+        assert len(results) >= 1
+        assert any(r.file_path == "app.py" for r in results)

semantic_code_intelligence/tests/test_embeddings.py

@@ -0,0 +1,73 @@
+"""Tests for the embedding generator."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from semantic_code_intelligence.embeddings.generator import (
+    generate_embeddings,
+    get_embedding_dimension,
+    get_model,
+)
+
+
+class TestGetModel:
+    """Tests for model loading."""
+
+    def test_loads_model(self):
+        model = get_model("all-MiniLM-L6-v2")
+        assert model is not None
+
+    def test_model_cached(self):
+        m1 = get_model("all-MiniLM-L6-v2")
+        m2 = get_model("all-MiniLM-L6-v2")
+        assert m1 is m2
+
+
+class TestGenerateEmbeddings:
+    """Tests for embedding generation."""
+
+    def test_returns_numpy_array(self):
+        emb = generate_embeddings(["hello world"])
+        assert isinstance(emb, np.ndarray)
+
+    def test_correct_shape(self):
+        texts = ["hello", "world", "foo"]
+        emb = generate_embeddings(texts)
+        assert emb.shape[0] == 3
+        assert emb.shape[1] > 0
+
+    def test_empty_input(self):
+        emb = generate_embeddings([])
+        assert emb.shape == (0, 0)
+
+    def test_embeddings_normalized(self):
+        emb = generate_embeddings(["test string"])
+        norm = np.linalg.norm(emb[0])
+        assert abs(norm - 1.0) < 0.01
+
+    def test_similar_texts_close(self):
+        emb = generate_embeddings([
+            "def authenticate_user(username, password):",
+            "def verify_user_credentials(user, pwd):",
+            "import random; x = random.randint(0, 100)",
+        ])
+        # Cosine similarity (already normalized, so dot product)
+        sim_related = np.dot(emb[0], emb[1])
+        sim_unrelated = np.dot(emb[0], emb[2])
+        assert sim_related > sim_unrelated
+
+
+class TestGetEmbeddingDimension:
+    """Tests for embedding dimension retrieval."""
+
+    def test_returns_positive_int(self):
+        dim = get_embedding_dimension()
+        assert isinstance(dim, int)
+        assert dim > 0
+
+    def test_matches_actual_embedding(self):
+        dim = get_embedding_dimension()
+        emb = generate_embeddings(["test"])
+        assert emb.shape[1] == dim