sia-code 0.2.2__tar.gz → 0.2.3__tar.gz

{sia_code-0.2.2 → sia_code-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sia-code
-Version: 0.2.2
+Version: 0.2.3
 Summary: Local-first codebase intelligence with semantic search, multi-hop research, and 12-language AST support
 Author: Sia Code Contributors
 License: MIT

{sia_code-0.2.2 → sia_code-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sia-code"
-version = "0.2.2"
+version = "0.2.3"
 description = "Local-first codebase intelligence with semantic search, multi-hop research, and 12-language AST support"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -98,7 +98,7 @@ python_classes = "Test*"
 python_functions = "test_*"
 
 [tool.bumpversion]
-current_version = "0.2.2"
+current_version = "0.2.3"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 commit = true

{sia_code-0.2.2 → sia_code-0.2.3}/sia_code/__init__.py

@@ -3,5 +3,5 @@
 Semantic search, multi-hop research, and 12-language AST support.
 """
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"
 __all__ = ["__version__"]

{sia_code-0.2.2 → sia_code-0.2.3}/sia_code/cli.py

@@ -381,14 +381,24 @@ def index(
                 console.print("[dim]Re-indexing...[/dim]")
 
                 try:
-                    # Perform incremental reindex
+                    # Perform incremental reindex using v2
                     from .indexer.hash_cache import HashCache
+                    from .indexer.chunk_index import ChunkIndex
 
                     cache_path = sia_dir / "cache" / "file_hashes.json"
                     cache = HashCache(cache_path)
 
+                    chunk_index_path = sia_dir / "chunk_index.json"
+                    chunk_index = ChunkIndex(chunk_index_path)
+                    chunk_index.load()
+
                     coordinator = IndexingCoordinator(backend=backend, config=config)
-                    stats = coordinator.index_directory_incremental(Path(path), cache)
+                    stats = coordinator.index_directory_incremental_v2(
+                        Path(path), cache, chunk_index, progress_callback=None
+                    )
+
+                    # Save updated chunk index
+                    chunk_index.save()
 
                     console.print(
                         f"[green]✓[/green] Re-indexed {stats['files_indexed']} files, {stats['chunks_indexed']} chunks"

{sia_code-0.2.2 → sia_code-0.2.3}/sia_code/indexer/coordinator.py

@@ -1,12 +1,11 @@
 """Indexing coordinator - orchestrates parse → chunk → store."""
 
 from pathlib import Path
-import hashlib
 import logging
 import time
 import os
 from concurrent.futures import ProcessPoolExecutor, as_completed
-from typing import cast, Callable
+from typing import Callable
 
 import pathspec
 
@@ -485,99 +484,6 @@ class IndexingCoordinator:
 
         return stats
 
-    def index_directory_incremental(self, directory: Path, cache: HashCache) -> dict:
-        """Index only changed files using hash cache.
-
-        Args:
-            directory: Root directory to index
-            cache: Hash cache for change detection
-
-        Returns:
-            Statistics dictionary
-        """
-        # Start performance tracking
-        metrics = PerformanceMetrics()
-
-        files = self._discover_files(directory)
-
-        stats = {
-            "total_files": len(files),
-            "changed_files": 0,
-            "skipped_files": 0,
-            "indexed_files": 0,
-            "total_chunks": 0,
-            "errors": [],
-            "metrics": None,  # Will be filled at end
-        }
-
-        for file_path in files:
-            # Check if file changed
-            if not cache.has_changed(file_path):
-                stats["skipped_files"] += 1
-                continue
-
-            stats["changed_files"] += 1
-
-            try:
-                language = Language.from_extension(file_path.suffix)
-
-                if not self.chunker.engine.is_supported(language):
-                    logger.debug(f"Skipping unsupported language: {file_path}")
-                    continue
-
-                # Get old chunk IDs for this file
-                old_chunk_ids = cache.get_chunks(file_path)
-
-                # Delete old chunks (placeholder - Memvid doesn't support direct delete)
-                if old_chunk_ids:
-                    logger.debug(
-                        f"Old chunks exist for {file_path} ({len(old_chunk_ids)}), "
-                        "but cannot delete (Memvid limitation)"
-                    )
-
-                # Chunk the file with retry
-                chunks, error = self._index_file_with_retry(file_path, language)
-
-                if error:
-                    stats["errors"].append(f"{file_path}: {error}")
-                    metrics.errors_count += 1
-                    continue
-
-                if chunks:
-                    # Track file size
-                    try:
-                        metrics.bytes_processed += file_path.stat().st_size
-                    except OSError:
-                        pass
-
-                    # Store new chunks
-                    chunk_ids = self.backend.store_chunks_batch(chunks)
-
-                    # Update cache with new chunk IDs
-                    cache.update(file_path, cast(list[str], chunk_ids))
-
-                    stats["indexed_files"] += 1
-                    stats["total_chunks"] += len(chunks)
-                    metrics.files_processed += 1
-                    metrics.chunks_created += len(chunks)
-                    logger.info(f"Re-indexed {file_path}: {len(chunks)} chunks")
-
-            except Exception as e:
-                error_msg = f"Unexpected error: {str(e)}"
-                stats["errors"].append(f"{file_path}: {error_msg}")
-                metrics.errors_count += 1
-                logger.exception(f"Unexpected error indexing {file_path}")
-
-        # Save updated cache
-        cache.save()
-
-        # Finalize metrics
-        metrics.finish()
-        stats["metrics"] = metrics.to_dict()
-        logger.info(f"Incremental indexing complete: {metrics}")
-
-        return stats
-
     def compact_index(
         self, directory: Path, chunk_index: ChunkIndex, threshold: float = 0.2
     ) -> dict:
@@ -722,18 +628,3 @@ class IndexingCoordinator:
         logger.info(f"Compaction complete: {metrics}")
 
         return stats
-
-    def get_file_hash(self, file_path: Path) -> str:
-        """Calculate file hash for change detection.
-
-        Args:
-            file_path: Path to file
-
-        Returns:
-            MD5 hash of file
-        """
-        hasher = hashlib.md5()
-        with open(file_path, "rb") as f:
-            for chunk in iter(lambda: f.read(4096), b""):
-                hasher.update(chunk)
-        return hasher.hexdigest()

{sia_code-0.2.2 → sia_code-0.2.3}/sia_code/parser/concepts.py

@@ -134,6 +134,157 @@ class ConceptExtractor:
         traverse(root)
         return concepts
 
+    def _extract_javascript_concepts(
+        self, root: Node, source_code: bytes
+    ) -> list[UniversalConcept]:
+        """Extract JavaScript/TypeScript-specific concepts."""
+        concepts = []
+
+        def traverse(node: Node, parent_class: str | None = None):
+            # Function declarations: function foo() {}
+            if node.type == "function_declaration":
+                name_node = node.child_by_field_name("name")
+                if name_node:
+                    symbol = source_code[name_node.start_byte : name_node.end_byte].decode("utf-8")
+                    concepts.append(
+                        UniversalConcept(
+                            concept_type=ConceptType.DEFINITION,
+                            chunk_type=ChunkType.FUNCTION,
+                            symbol=symbol,
+                            start_line=LineNumber(node.start_point[0] + 1),
+                            end_line=LineNumber(node.end_point[0] + 1),
+                            start_byte=ByteOffset(node.start_byte),
+                            end_byte=ByteOffset(node.end_byte),
+                            code=source_code[node.start_byte : node.end_byte].decode("utf-8"),
+                            parent_header=parent_class,
+                        )
+                    )
+
+            # Arrow functions and function expressions: const foo = () => {}
+            elif node.type in ("arrow_function", "function_expression", "function"):
+                # Try to find the parent variable declarator to get the name
+                parent = node.parent
+                symbol = "anonymous"
+                if parent and parent.type == "variable_declarator":
+                    name_node = parent.child_by_field_name("name")
+                    if name_node:
+                        symbol = source_code[name_node.start_byte : name_node.end_byte].decode(
+                            "utf-8"
+                        )
+
+                concepts.append(
+                    UniversalConcept(
+                        concept_type=ConceptType.DEFINITION,
+                        chunk_type=ChunkType.FUNCTION,
+                        symbol=symbol,
+                        start_line=LineNumber(node.start_point[0] + 1),
+                        end_line=LineNumber(node.end_point[0] + 1),
+                        start_byte=ByteOffset(node.start_byte),
+                        end_byte=ByteOffset(node.end_byte),
+                        code=source_code[node.start_byte : node.end_byte].decode("utf-8"),
+                        parent_header=parent_class,
+                    )
+                )
+
+            # Class declarations
+            elif node.type == "class_declaration":
+                name_node = node.child_by_field_name("name")
+                if name_node:
+                    symbol = source_code[name_node.start_byte : name_node.end_byte].decode("utf-8")
+                    concepts.append(
+                        UniversalConcept(
+                            concept_type=ConceptType.DEFINITION,
+                            chunk_type=ChunkType.CLASS,
+                            symbol=symbol,
+                            start_line=LineNumber(node.start_point[0] + 1),
+                            end_line=LineNumber(node.end_point[0] + 1),
+                            start_byte=ByteOffset(node.start_byte),
+                            end_byte=ByteOffset(node.end_byte),
+                            code=source_code[node.start_byte : node.end_byte].decode("utf-8"),
+                        )
+                    )
+                    # Traverse children with class context
+                    for child in node.children:
+                        traverse(child, parent_class=symbol)
+                    return  # Don't traverse again
+
+            # Method definitions (inside classes)
+            elif node.type in ("method_definition", "public_field_definition"):
+                name_node = node.child_by_field_name("name")
+                if name_node:
+                    symbol = source_code[name_node.start_byte : name_node.end_byte].decode("utf-8")
+                    concepts.append(
+                        UniversalConcept(
+                            concept_type=ConceptType.DEFINITION,
+                            chunk_type=ChunkType.METHOD if parent_class else ChunkType.FUNCTION,
+                            symbol=symbol,
+                            start_line=LineNumber(node.start_point[0] + 1),
+                            end_line=LineNumber(node.end_point[0] + 1),
+                            start_byte=ByteOffset(node.start_byte),
+                            end_byte=ByteOffset(node.end_byte),
+                            code=source_code[node.start_byte : node.end_byte].decode("utf-8"),
+                            parent_header=parent_class,
+                        )
+                    )
+
+            # TypeScript-specific: interface declarations
+            elif node.type == "interface_declaration":
+                name_node = node.child_by_field_name("name")
+                if name_node:
+                    symbol = source_code[name_node.start_byte : name_node.end_byte].decode("utf-8")
+                    concepts.append(
+                        UniversalConcept(
+                            concept_type=ConceptType.DEFINITION,
+                            chunk_type=ChunkType.CLASS,  # Treat interfaces like classes
+                            symbol=symbol,
+                            start_line=LineNumber(node.start_point[0] + 1),
+                            end_line=LineNumber(node.end_point[0] + 1),
+                            start_byte=ByteOffset(node.start_byte),
+                            end_byte=ByteOffset(node.end_byte),
+                            code=source_code[node.start_byte : node.end_byte].decode("utf-8"),
+                        )
+                    )
+
+            # TypeScript-specific: type alias declarations
+            elif node.type == "type_alias_declaration":
+                name_node = node.child_by_field_name("name")
+                if name_node:
+                    symbol = source_code[name_node.start_byte : name_node.end_byte].decode("utf-8")
+                    concepts.append(
+                        UniversalConcept(
+                            concept_type=ConceptType.DEFINITION,
+                            chunk_type=ChunkType.CLASS,  # Treat type aliases like classes
+                            symbol=symbol,
+                            start_line=LineNumber(node.start_point[0] + 1),
+                            end_line=LineNumber(node.end_point[0] + 1),
+                            start_byte=ByteOffset(node.start_byte),
+                            end_byte=ByteOffset(node.end_byte),
+                            code=source_code[node.start_byte : node.end_byte].decode("utf-8"),
+                        )
+                    )
+
+            # Comments
+            elif node.type == "comment":
+                concepts.append(
+                    UniversalConcept(
+                        concept_type=ConceptType.COMMENT,
+                        chunk_type=ChunkType.COMMENT,
+                        symbol="comment",
+                        start_line=LineNumber(node.start_point[0] + 1),
+                        end_line=LineNumber(node.end_point[0] + 1),
+                        start_byte=ByteOffset(node.start_byte),
+                        end_byte=ByteOffset(node.end_byte),
+                        code=source_code[node.start_byte : node.end_byte].decode("utf-8"),
+                    )
+                )
+
+            # Traverse children
+            for child in node.children:
+                traverse(child, parent_class)
+
+        traverse(root)
+        return concepts
+
     def _extract_generic_concepts(self, root: Node, source_code: bytes) -> list[UniversalConcept]:
         """Extract concepts from C-like languages using common node types."""
         concepts = []

{sia_code-0.2.2 → sia_code-0.2.3}/sia_code/parser/engine.py

@@ -100,8 +100,11 @@ class TreeSitterEngine:
             with open(file_path, "rb") as f:
                 source_code = f.read()
             return self.parse_code(source_code, language)
-        except Exception:
-            # Silent fail for individual files
+        except Exception as e:
+            # Log parse failures for debugging
+            import logging
+
+            logging.getLogger(__name__).debug(f"Parse failed for {file_path}: {e}")
             return None
 
     def parse_code(self, source_code: bytes | str, language: PciLanguage):
@@ -116,7 +119,11 @@ class TreeSitterEngine:
             parser = self._parsers[language]
             tree = parser.parse(source_code)
             return tree.root_node
-        except Exception:
+        except Exception as e:
+            # Log parse failures for debugging
+            import logging
+
+            logging.getLogger(__name__).debug(f"Parse code failed for {language}: {e}")
             return None
 
     def is_supported(self, language: PciLanguage) -> bool:

{sia_code-0.2.2 → sia_code-0.2.3}/sia_code/search/entity_extractor.py

@@ -52,8 +52,13 @@ class EntityExtractor:
             elif chunk.language in [Language.JAVASCRIPT, Language.TYPESCRIPT, Language.TSX]:
                 entities.extend(self._extract_js_entities(root, chunk))
 
-        except Exception:
-            # Silent fail for extraction errors
+        except Exception as e:
+            # Log extraction failures for debugging
+            import logging
+
+            logging.getLogger(__name__).debug(
+                f"Entity extraction failed for chunk {chunk.symbol}: {e}"
+            )
             pass
 
         return entities

{sia_code-0.2.2 → sia_code-0.2.3}/sia_code/search/multi_hop.py

@@ -107,7 +107,13 @@ class MultiHopSearchStrategy:
                 # Search for this entity
                 try:
                     entity_results = self.backend.search_lexical(entity.name, k=3)
-                except Exception:
+                except Exception as e:
+                    # Log search failures for debugging
+                    import logging
+
+                    logging.getLogger(__name__).debug(
+                        f"Entity search failed for {entity.name}: {e}"
+                    )
                     continue
 
                 # Process results

{sia_code-0.2.2 → sia_code-0.2.3}/sia_code.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sia-code
-Version: 0.2.2
+Version: 0.2.3
 Summary: Local-first codebase intelligence with semantic search, multi-hop research, and 12-language AST support
 Author: Sia Code Contributors
 License: MIT

{sia_code-0.2.2 → sia_code-0.2.3}/tests/test_basic.py

@@ -98,7 +98,9 @@ class TestMemvidBackend:
         backend.store_chunks_batch(sample_chunks)
 
         results = backend.search_lexical("search", k=5)
-        assert len(results) > 0
+
+        # Respect the k parameter
+        assert 1 <= len(results) <= 5
 
         # Check result structure
         for result in results:
@@ -106,23 +108,42 @@ class TestMemvidBackend:
             assert result.chunk.symbol is not None
             assert result.score > 0  # BM25 scores are positive
 
+        # Verify results are sorted by score (descending)
+        scores = [r.score for r in results]
+        assert scores == sorted(scores, reverse=True), (
+            "Results should be sorted by score (descending)"
+        )
+
     def test_lexical_search_multiple_terms(self, backend, sample_chunks):
         """Test lexical search with multiple terms."""
         backend.store_chunks_batch(sample_chunks)
 
         results = backend.search_lexical("semantic code chunk", k=5)
-        assert len(results) > 0
+
+        # Respect the k parameter
+        assert 1 <= len(results) <= 5
+
+        # Verify results are sorted by relevance
+        scores = [r.score for r in results]
+        assert scores == sorted(scores, reverse=True)
 
     def test_lexical_search_language(self, backend, sample_chunks):
         """Test lexical search finds language-related content."""
         backend.store_chunks_batch(sample_chunks)
 
         results = backend.search_lexical("languages", k=5)
-        assert len(results) > 0
+
+        # Respect the k parameter
+        assert 1 <= len(results) <= 5
+
         # Should find the Language class
         symbols = [r.chunk.symbol for r in results]
         assert "Language" in symbols
 
+        # Verify scores are descending
+        scores = [r.score for r in results]
+        assert scores == sorted(scores, reverse=True)
+
 
 class TestChunkModel:
     """Test Chunk model validation."""