codexa 0.4.0__py3-none-any.whl

semantic_code_intelligence/tests/test_ai_features.py

@@ -0,0 +1,351 @@
+"""Tests for AI features — repository summary, AI context, code explanations."""
+
+import json
+
+import pytest
+
+from semantic_code_intelligence.analysis.ai_features import (
+    CodeExplanation,
+    LanguageStats,
+    RepoSummary,
+    explain_file,
+    explain_symbol,
+    generate_ai_context,
+    summarize_repository,
+)
+from semantic_code_intelligence.context.engine import ContextBuilder
+
+
+# ---------------------------------------------------------------------------
+# 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);
+    }
+}
+'''
+
+
+# ---------------------------------------------------------------------------
+# RepoSummary
+# ---------------------------------------------------------------------------
+
+class TestRepoSummary:
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        self.builder = ContextBuilder()
+        self.builder.index_file("app.py", PYTHON_SAMPLE)
+        self.builder.index_file("app.js", JS_SAMPLE)
+        self.summary = summarize_repository(self.builder)
+
+    def test_total_files(self):
+        assert self.summary.total_files == 2
+
+    def test_total_symbols(self):
+        assert self.summary.total_symbols > 0
+
+    def test_total_functions(self):
+        assert self.summary.total_functions >= 2  # helper, main, parse, load
+
+    def test_total_classes(self):
+        assert self.summary.total_classes >= 2  # Worker, DataLoader
+
+    def test_total_methods(self):
+        assert self.summary.total_methods >= 2
+
+    def test_total_imports(self):
+        assert self.summary.total_imports >= 2
+
+    def test_languages_listed(self):
+        lang_names = {l.language for l in self.summary.languages}
+        assert "python" in lang_names
+        assert "javascript" in lang_names
+
+    def test_top_functions(self):
+        assert len(self.summary.top_functions) > 0
+        assert "name" in self.summary.top_functions[0]
+
+    def test_top_classes(self):
+        assert len(self.summary.top_classes) > 0
+        assert "name" in self.summary.top_classes[0]
+
+    def test_to_dict(self):
+        d = self.summary.to_dict()
+        assert "total_files" in d
+        assert "languages" in d
+        assert "top_functions" in d
+
+    def test_to_json(self):
+        j = self.summary.to_json()
+        parsed = json.loads(j)
+        assert parsed["total_files"] == 2
+
+    def test_render(self):
+        text = self.summary.render()
+        assert "Repository Summary" in text
+        assert "Files:" in text
+        assert "Languages" in text
+
+
+class TestLanguageStats:
+    def test_to_dict(self):
+        stats = LanguageStats(
+            language="python",
+            file_count=5,
+            function_count=10,
+            class_count=3,
+        )
+        d = stats.to_dict()
+        assert d["language"] == "python"
+        assert d["file_count"] == 5
+        assert d["function_count"] == 10
+        assert d["class_count"] == 3
+
+
+class TestRepoSummaryEmpty:
+    def test_empty_builder(self):
+        builder = ContextBuilder()
+        summary = summarize_repository(builder)
+        assert summary.total_files == 0
+        assert summary.total_symbols == 0
+        assert summary.languages == []
+
+    def test_single_file(self):
+        builder = ContextBuilder()
+        builder.index_file("app.py", PYTHON_SAMPLE)
+        summary = summarize_repository(builder)
+        assert summary.total_files == 1
+        lang_names = {l.language for l in summary.languages}
+        assert "python" in lang_names
+
+
+# ---------------------------------------------------------------------------
+# AI Context Generation
+# ---------------------------------------------------------------------------
+
+class TestGenerateAIContext:
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        self.builder = ContextBuilder()
+        self.builder.index_file("app.py", PYTHON_SAMPLE)
+        self.builder.index_file("app.js", JS_SAMPLE)
+
+    def test_basic_context(self):
+        ctx = generate_ai_context(self.builder)
+        assert "summary" in ctx
+        assert "call_graph" in ctx
+        assert "dependencies" in ctx
+
+    def test_context_with_symbol_focus(self):
+        ctx = generate_ai_context(self.builder, symbol_name="helper")
+        assert "focused_contexts" in ctx
+        assert len(ctx["focused_contexts"]) >= 1
+
+    def test_context_with_file_focus(self):
+        ctx = generate_ai_context(self.builder, file_path="app.py")
+        assert "file_symbols" in ctx
+        assert len(ctx["file_symbols"]) > 0
+
+    def test_context_without_call_graph(self):
+        ctx = generate_ai_context(self.builder, include_call_graph=False)
+        assert "call_graph" not in ctx
+
+    def test_context_without_dependencies(self):
+        ctx = generate_ai_context(self.builder, include_dependencies=False)
+        assert "dependencies" not in ctx
+
+    def test_context_is_json_serializable(self):
+        ctx = generate_ai_context(self.builder)
+        j = json.dumps(ctx)
+        assert len(j) > 0
+
+    def test_call_graph_has_edges(self):
+        ctx = generate_ai_context(self.builder)
+        assert ctx["call_graph"]["edge_count"] > 0
+
+    def test_dependencies_has_files(self):
+        ctx = generate_ai_context(self.builder)
+        assert "app.py" in ctx["dependencies"]
+
+
+# ---------------------------------------------------------------------------
+# Code Explanation
+# ---------------------------------------------------------------------------
+
+class TestExplainSymbol:
+    @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()
+
+    def test_explain_function(self):
+        func = next(s for s in self.symbols if s.name == "helper")
+        explanation = explain_symbol(func)
+        assert explanation.symbol_name == "helper"
+        assert explanation.symbol_kind == "function"
+        assert "Function" in explanation.summary
+        assert "helper" in explanation.summary
+
+    def test_explain_class(self):
+        cls = next(s for s in self.symbols if s.name == "Worker")
+        explanation = explain_symbol(cls)
+        assert explanation.symbol_name == "Worker"
+        assert "Class" in explanation.summary
+
+    def test_explain_method(self):
+        method = next(s for s in self.symbols if s.name == "process")
+        explanation = explain_symbol(method)
+        assert explanation.symbol_name == "process"
+        assert "Method" in explanation.summary
+        assert "Worker" in explanation.summary
+
+    def test_explain_import(self):
+        imp = next(s for s in self.symbols if s.kind == "import")
+        explanation = explain_symbol(imp)
+        assert "Import" in explanation.summary
+
+    def test_explain_with_builder_context(self):
+        func = next(s for s in self.symbols if s.name == "main")
+        explanation = explain_symbol(func, self.builder)
+        assert "related_symbols" in explanation.details or "file_imports" in explanation.details
+
+    def test_explanation_to_dict(self):
+        func = next(s for s in self.symbols if s.name == "helper")
+        explanation = explain_symbol(func)
+        d = explanation.to_dict()
+        assert "symbol_name" in d
+        assert "summary" in d
+        assert "details" in d
+
+    def test_explanation_render(self):
+        func = next(s for s in self.symbols if s.name == "helper")
+        explanation = explain_symbol(func)
+        text = explanation.render()
+        assert "helper" in text
+        assert "File:" in text
+
+    def test_explanation_render_with_details(self):
+        func = next(s for s in self.symbols if s.name == "main")
+        explanation = explain_symbol(func, self.builder)
+        text = explanation.render()
+        assert "main" in text
+
+
+class TestExplainFile:
+    def test_explain_python_file(self):
+        explanations = explain_file("app.py", PYTHON_SAMPLE)
+        assert len(explanations) > 0
+        # Should not include imports
+        for e in explanations:
+            assert e.symbol_kind != "import"
+
+    def test_explain_js_file(self):
+        explanations = explain_file("app.js", JS_SAMPLE)
+        assert len(explanations) > 0
+
+    def test_explain_empty_file(self):
+        explanations = explain_file("empty.py", "")
+        assert explanations == []
+
+    def test_explain_unsupported_file(self):
+        explanations = explain_file("style.css", "body { color: red; }")
+        assert explanations == []
+
+    def test_each_explanation_has_name(self):
+        explanations = explain_file("app.py", PYTHON_SAMPLE)
+        for e in explanations:
+            assert e.symbol_name
+            assert e.file_path == "app.py"
+
+
+class TestCodeExplanation:
+    def test_dataclass_fields(self):
+        exp = CodeExplanation(
+            symbol_name="foo",
+            symbol_kind="function",
+            file_path="test.py",
+            summary="A test function.",
+            details={"parameters": "a, b"},
+        )
+        assert exp.symbol_name == "foo"
+        assert exp.details["parameters"] == "a, b"
+
+    def test_render_empty_details(self):
+        exp = CodeExplanation(
+            symbol_name="foo",
+            symbol_kind="function",
+            file_path="test.py",
+            summary="A test function.",
+        )
+        text = exp.render()
+        assert "foo" in text
+        assert "Function" in text
+
+
+# ---------------------------------------------------------------------------
+# Edge cases
+# ---------------------------------------------------------------------------
+
+class TestAIFeaturesEdgeCases:
+    def test_summary_single_symbol(self):
+        builder = ContextBuilder()
+        builder.index_file("one.py", "def single(): pass\n")
+        summary = summarize_repository(builder)
+        assert summary.total_functions == 1
+        assert summary.total_files == 1
+
+    def test_ai_context_empty_builder(self):
+        builder = ContextBuilder()
+        ctx = generate_ai_context(builder)
+        assert ctx["summary"]["total_files"] == 0
+
+    def test_ai_context_nonexistent_symbol(self):
+        builder = ContextBuilder()
+        builder.index_file("app.py", PYTHON_SAMPLE)
+        ctx = generate_ai_context(builder, symbol_name="nonexistent")
+        assert ctx["focused_contexts"] == []
+
+    def test_ai_context_nonexistent_file(self):
+        builder = ContextBuilder()
+        builder.index_file("app.py", PYTHON_SAMPLE)
+        ctx = generate_ai_context(builder, file_path="nonexistent.py")
+        assert ctx["file_symbols"] == []

semantic_code_intelligence/tests/test_chunker.py

@@ -0,0 +1,119 @@
+"""Tests for the code chunker."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from semantic_code_intelligence.indexing.chunker import (
+    CodeChunk,
+    chunk_code,
+    chunk_file,
+    detect_language,
+)
+
+
+class TestDetectLanguage:
+    """Tests for language detection."""
+
+    def test_python(self):
+        assert detect_language("main.py") == "python"
+
+    def test_javascript(self):
+        assert detect_language("app.js") == "javascript"
+
+    def test_typescript(self):
+        assert detect_language("component.tsx") == "typescript"
+
+    def test_java(self):
+        assert detect_language("Main.java") == "java"
+
+    def test_unknown(self):
+        assert detect_language("data.xyz") == "unknown"
+
+    def test_path_with_directory(self):
+        assert detect_language("/some/path/file.py") == "python"
+        assert detect_language("C:\\code\\file.js") == "javascript"
+
+
+class TestChunkCode:
+    """Tests for code chunking logic."""
+
+    def test_empty_content(self):
+        chunks = chunk_code("", "test.py")
+        assert chunks == []
+
+    def test_whitespace_only(self):
+        chunks = chunk_code("   \n  \n ", "test.py")
+        assert chunks == []
+
+    def test_small_file_single_chunk(self):
+        code = "def hello():\n    return 'world'\n"
+        chunks = chunk_code(code, "test.py", chunk_size=1000)
+        assert len(chunks) == 1
+        assert chunks[0].content == code
+        assert chunks[0].start_line == 1
+        assert chunks[0].end_line == 2
+        assert chunks[0].language == "python"
+        assert chunks[0].chunk_index == 0
+
+    def test_large_file_multiple_chunks(self):
+        lines = [f"line_{i} = {i}\n" for i in range(100)]
+        code = "".join(lines)
+        chunks = chunk_code(code, "test.py", chunk_size=200, chunk_overlap=50)
+        assert len(chunks) > 1
+
+    def test_chunks_cover_all_content(self):
+        lines = [f"x_{i} = {i}\n" for i in range(50)]
+        code = "".join(lines)
+        chunks = chunk_code(code, "test.py", chunk_size=100, chunk_overlap=20)
+        # Every line should appear in at least one chunk
+        all_chunk_text = "".join(c.content for c in chunks)
+        for line in lines:
+            assert line in all_chunk_text
+
+    def test_chunk_index_sequential(self):
+        lines = [f"var_{i} = {i}\n" for i in range(100)]
+        code = "".join(lines)
+        chunks = chunk_code(code, "test.py", chunk_size=150, chunk_overlap=30)
+        for i, chunk in enumerate(chunks):
+            assert chunk.chunk_index == i
+
+    def test_chunk_metadata(self):
+        code = "function hello() { return 1; }\n"
+        chunks = chunk_code(code, "app.js", chunk_size=1000)
+        assert chunks[0].file_path == "app.js"
+        assert chunks[0].language == "javascript"
+
+    def test_overlap_between_chunks(self):
+        lines = [f"line_{i:03d} = {i}\n" for i in range(100)]
+        code = "".join(lines)
+        chunks = chunk_code(code, "test.py", chunk_size=200, chunk_overlap=50)
+        if len(chunks) >= 2:
+            # Last lines of chunk N should appear in chunk N+1
+            chunk0_lines = set(chunks[0].content.splitlines())
+            chunk1_lines = set(chunks[1].content.splitlines())
+            overlap = chunk0_lines & chunk1_lines
+            assert len(overlap) > 0
+
+
+class TestChunkFile:
+    """Tests for file-based chunking."""
+
+    def test_chunk_existing_file(self, tmp_path: Path):
+        f = tmp_path / "test.py"
+        f.write_text("def hello():\n    pass\n", encoding="utf-8")
+        chunks = chunk_file(f, chunk_size=1000)
+        assert len(chunks) == 1
+
+    def test_chunk_nonexistent_file(self, tmp_path: Path):
+        f = tmp_path / "missing.py"
+        chunks = chunk_file(f)
+        assert chunks == []
+
+    def test_chunk_empty_file(self, tmp_path: Path):
+        f = tmp_path / "empty.py"
+        f.write_text("", encoding="utf-8")
+        chunks = chunk_file(f)
+        assert chunks == []

semantic_code_intelligence/tests/test_cli.py

@@ -0,0 +1,188 @@
+"""Tests for CLI commands and routing."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+from click.testing import CliRunner
+
+from semantic_code_intelligence.cli.main import cli
+
+
+@pytest.fixture
+def runner() -> CliRunner:
+    """Provide a Click test runner."""
+    return CliRunner()
+
+
+@pytest.fixture
+def initialized_project(tmp_path: Path) -> Path:
+    """Create an initialized project directory."""
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path) as td:
+        project = Path(td)
+        runner.invoke(cli, ["init", str(project)])
+        yield project
+
+
+class TestCLIMain:
+    """Tests for the main CLI group."""
+
+    def test_cli_help(self, runner: CliRunner):
+        result = runner.invoke(cli, ["--help"])
+        assert result.exit_code == 0
+        assert "Codex" in result.output
+
+    def test_cli_version(self, runner: CliRunner):
+        result = runner.invoke(cli, ["--version"])
+        assert result.exit_code == 0
+        assert "0.4.0" in result.output
+
+    def test_cli_verbose_flag(self, runner: CliRunner):
+        result = runner.invoke(cli, ["--verbose", "--help"])
+        assert result.exit_code == 0
+
+
+class TestInitCommand:
+    """Tests for the init command."""
+
+    def test_init_creates_project(self, runner: CliRunner, tmp_path: Path):
+        result = runner.invoke(cli, ["init", str(tmp_path)])
+        assert result.exit_code == 0
+        assert (tmp_path / ".codexa").is_dir()
+        assert (tmp_path / ".codexa" / "config.json").exists()
+        assert (tmp_path / ".codexa" / "index").is_dir()
+
+    def test_init_already_initialized(self, runner: CliRunner, tmp_path: Path):
+        # First init
+        runner.invoke(cli, ["init", str(tmp_path)])
+        # Second init should detect existing
+        result = runner.invoke(cli, ["init", str(tmp_path)])
+        assert result.exit_code == 0
+        assert "already initialized" in result.output
+
+    def test_init_default_path(self, runner: CliRunner):
+        with runner.isolated_filesystem() as td:
+            result = runner.invoke(cli, ["init"])
+            assert result.exit_code == 0
+            assert Path(td, ".codexa").is_dir()
+
+
+class TestIndexCommand:
+    """Tests for the index command."""
+
+    def test_index_without_init_fails(self, runner: CliRunner, tmp_path: Path):
+        result = runner.invoke(cli, ["index", str(tmp_path)])
+        assert result.exit_code != 0 or "not initialized" in result.output.lower()
+
+    def test_index_initialized_project(self, runner: CliRunner, tmp_path: Path):
+        # Initialize first
+        runner.invoke(cli, ["init", str(tmp_path)])
+        result = runner.invoke(cli, ["index", str(tmp_path)])
+        assert result.exit_code == 0
+        assert "Indexing" in result.output or "index" in result.output.lower()
+
+    def test_index_with_python_files(self, runner: CliRunner, tmp_path: Path):
+        # Create some Python files
+        (tmp_path / "main.py").write_text("def hello(): pass", encoding="utf-8")
+        (tmp_path / "utils.py").write_text("def helper(): pass", encoding="utf-8")
+
+        runner.invoke(cli, ["init", str(tmp_path)])
+        result = runner.invoke(cli, ["index", str(tmp_path)])
+        assert result.exit_code == 0
+        # Should find 2 py files (not counting files in .codexa)
+        assert "2 files" in result.output
+
+    def test_index_ignores_excluded_dirs(self, runner: CliRunner, tmp_path: Path):
+        # Create files in ignored directories
+        (tmp_path / "main.py").write_text("def hello(): pass", encoding="utf-8")
+        node_modules = tmp_path / "node_modules"
+        node_modules.mkdir()
+        (node_modules / "pkg.js").write_text("function f(){}", encoding="utf-8")
+
+        runner.invoke(cli, ["init", str(tmp_path)])
+        result = runner.invoke(cli, ["index", str(tmp_path)])
+        assert result.exit_code == 0
+        assert "1 files" in result.output
+
+    def test_index_force_flag(self, runner: CliRunner, tmp_path: Path):
+        runner.invoke(cli, ["init", str(tmp_path)])
+        result = runner.invoke(cli, ["index", str(tmp_path), "--force"])
+        assert result.exit_code == 0
+
+
+class TestSearchCommand:
+    """Tests for the search command."""
+
+    def test_search_without_init_fails(self, runner: CliRunner, tmp_path: Path):
+        result = runner.invoke(cli, ["search", "test query", "--path", str(tmp_path)])
+        assert result.exit_code != 0 or "not initialized" in result.output.lower()
+
+    def test_search_human_readable(self, runner: CliRunner, tmp_path: Path):
+        runner.invoke(cli, ["init", str(tmp_path)])
+        result = runner.invoke(
+            cli, ["search", "test query", "--path", str(tmp_path)]
+        )
+        assert result.exit_code == 0
+        # Without an index, shows empty index warning
+        assert "empty" in result.output.lower() or "no results" in result.output.lower()
+
+    def test_search_json_output(self, runner: CliRunner, tmp_path: Path):
+        runner.invoke(cli, ["init", str(tmp_path)])
+        result = runner.invoke(
+            cli, ["search", "jwt verification", "--json", "--no-auto-index", "--path", str(tmp_path)]
+        )
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert data["query"] == "jwt verification"
+        assert "results" in data
+        assert isinstance(data["results"], list)
+
+    def test_search_custom_top_k(self, runner: CliRunner, tmp_path: Path):
+        runner.invoke(cli, ["init", str(tmp_path)])
+        result = runner.invoke(
+            cli,
+            ["search", "query", "-k", "5", "--json", "--no-auto-index", "--path", str(tmp_path)],
+        )
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert data["top_k"] == 5
+
+    def test_search_default_top_k_from_config(self, runner: CliRunner, tmp_path: Path):
+        runner.invoke(cli, ["init", str(tmp_path)])
+        result = runner.invoke(
+            cli,
+            ["search", "query", "--json", "--no-auto-index", "--path", str(tmp_path)],
+        )
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert data["top_k"] == 10  # default from config
+
+
+class TestCommandRouting:
+    """Tests that all commands are properly registered and routable."""
+
+    def test_all_commands_registered(self, runner: CliRunner):
+        result = runner.invoke(cli, ["--help"])
+        assert result.exit_code == 0
+        # All Phase 1 commands should appear in help
+        for cmd_name in ["init", "index", "search"]:
+            assert cmd_name in result.output
+
+    def test_init_command_accessible(self, runner: CliRunner):
+        result = runner.invoke(cli, ["init", "--help"])
+        assert result.exit_code == 0
+
+    def test_index_command_accessible(self, runner: CliRunner):
+        result = runner.invoke(cli, ["index", "--help"])
+        assert result.exit_code == 0
+
+    def test_search_command_accessible(self, runner: CliRunner):
+        result = runner.invoke(cli, ["search", "--help"])
+        assert result.exit_code == 0
+
+    def test_unknown_command_fails(self, runner: CliRunner):
+        result = runner.invoke(cli, ["nonexistent"])
+        assert result.exit_code != 0