code-intelligence 1.0.0__py3-none-win_amd64.whl → 1.2.0__py3-none-win_amd64.whl

code_intelligence/__init__.py

@@ -1,19 +1,16 @@
-"""
-Code Intelligence Library
-
-A lightweight, fast Tree-sitter based code intelligence library.
-Provides symbol database functionality for code analysis.
-"""
-
 from .symdb import (
     Language,
     SymbolType,
     Symbol,
     Location,
-    SymbolDatabase,
+    ImmideateSymbolDatabase,
+    LazySymbolDatabase,
 )
 
-__version__ = "1.0.0"
+# Backward compatibility alias
+SymbolDatabase = ImmideateSymbolDatabase
+
+__version__ = "1.2.0"
 __version_info__ = tuple(int(i) for i in __version__.split('.'))
 
 __all__ = [
@@ -21,5 +18,7 @@ __all__ = [
     "SymbolType",
     "Symbol",
     "Location",
+    "ImmideateSymbolDatabase",
+    "LazySymbolDatabase",
     "SymbolDatabase",
 ]

code_intelligence/symdb.py

@@ -3,6 +3,7 @@ import ctypes
 import platform
 from enum import IntEnum
 from pathlib import Path
+from dataclasses import dataclass, field
 
 
 class Language(IntEnum):
@@ -48,29 +49,29 @@ class SymbolType(IntEnum):
 
 Path_Like = str | Path
 
+@dataclass(slots=True)
 class Location:
-    def __init__(self, path: str, line: int, column: int, end_line: int = 0, end_column: int = 0):
-        self.path = path
-        self.line = line
-        self.column = column
-        self.end_line = end_line
-        self.end_column = end_column
-
-    def __repr__(self):
+    """Source code span."""
+    path: str = ""
+    line: int = 0
+    column: int = 0
+    end_line: int = 0
+    end_column: int = 0
+
+    def __repr__(self) -> str:
         return f"Location({self.path}:{self.line}:{self.column})"
 
+@dataclass(slots=True)
 class Symbol:
-    def __init__(self, name: str, symbol_type: SymbolType, definition: Location,
-                 parent: str | None = None, signature: str | None = None,
-                 documentation: str | None = None):
-        self.name = name
-        self.symbol_type = symbol_type
-        self.definition = definition
-        self.parent = parent
-        self.signature = signature
-        self.documentation = documentation
-
-    def __repr__(self):
+    """Language-agnostic symbol record."""
+    name: str = ""
+    symbol_type: SymbolType = SymbolType.UNKNOWN
+    definition: Location = field(default_factory=Location)
+    parent: str | None = None
+    signature: str | None = None
+    documentation: str | None = None
+
+    def __repr__(self) -> str:
         return f"Symbol({self.name}, {self.symbol_type.name}, {self.definition})"
 
     # Convenience properties for backward compatibility with TASK.md API
@@ -185,9 +186,69 @@ _lib.symbol_db_get_symbol.restype = ctypes.c_bool
 _lib.symbol_array_free.argtypes = [ctypes.c_void_p]
 _lib.symbol_array_free.restype = None
 
+_lib.ci_flush_coverage.argtypes = []
+_lib.ci_flush_coverage.restype = None
+
+_lib.symbol_db_clear.argtypes = [ctypes.c_void_p, ctypes.c_int]
+_lib.symbol_db_clear.restype = None
+
+def _flush_coverage():
+    try:
+        _lib.ci_flush_coverage()
+    except Exception:
+        pass
 
 # Helper conversions
 
+class CStringView:
+    """A view into a C string that delays decoding until needed."""
+    __slots__ = ('_ptr', '_decoded')
+    
+    def __init__(self, c_char_p):
+        self._ptr = c_char_p
+        self._decoded = None
+    
+    def __str__(self):
+        if self._decoded is None:
+            if self._ptr:
+                self._decoded = self._ptr.decode("utf-8", errors="replace")
+            else:
+                self._decoded = ""
+        return self._decoded
+    
+    def __repr__(self):
+        return f"CStringView({str(self)!r})"
+    
+    def __bool__(self):
+        return bool(self._ptr)
+    
+    def __eq__(self, other):
+        if isinstance(other, CStringView):
+            return str(self) == str(other)
+        elif isinstance(other, str):
+            return str(self) == other
+        return False
+
+
+def _to_py_symbol_lazy(c_symbol: _Symbol) -> Symbol:
+    """Convert C symbol to Python symbol with lazy string decoding."""
+    definition = Location(
+        path=str(CStringView(c_symbol.definition.path)),  # Decode immediately for file paths (needed for path operations)
+        line=c_symbol.definition.line,
+        column=c_symbol.definition.column,
+        end_line=c_symbol.definition.end_line,
+        end_column=c_symbol.definition.end_column,
+    )
+    return Symbol(
+        name=str(CStringView(c_symbol.name)),  # Most accessed field, decode immediately
+        symbol_type=SymbolType(c_symbol.symbol_type),
+        definition=definition,
+        parent=str(CStringView(c_symbol.parent)) if c_symbol.parent else None,
+        signature=CStringView(c_symbol.signature) if c_symbol.signature else None,  # Keep as view
+        documentation=CStringView(c_symbol.documentation) if c_symbol.documentation else None,  # Keep as view
+    )
+
+
 def _to_py_symbol(c_symbol: _Symbol) -> Symbol:
     definition = Location(
         path=c_symbol.definition.path.decode("utf-8", errors="replace") if c_symbol.definition.path else "",
@@ -206,6 +267,48 @@ def _to_py_symbol(c_symbol: _Symbol) -> Symbol:
     )
 
 
+class SymbolArrayView:
+    """A view into a C symbol array that manages the C memory and provides lazy access."""
+    
+    def __init__(self, ptr: ctypes.POINTER(_Symbol), count: int):
+        self._ptr = ptr
+        self._count = count
+        self._symbols = None  # Lazy converted symbols
+    
+    def __len__(self):
+        return self._count
+    
+    def __getitem__(self, index):
+        if isinstance(index, slice):
+            # Handle slice objects
+            start, stop, step = index.indices(self._count)
+            return [self[i] for i in range(start, stop, step)]
+        
+        if index < 0:
+            index = self._count + index
+        if index < 0 or index >= self._count:
+            raise IndexError("Symbol array index out of range")
+        
+        # Lazy conversion - convert only accessed symbols
+        if self._symbols is None:
+            self._symbols = [None] * self._count
+        
+        if self._symbols[index] is None:
+            self._symbols[index] = _to_py_symbol_lazy(self._ptr[index])
+        
+        return self._symbols[index]
+    
+    def __iter__(self):
+        for i in range(self._count):
+            yield self[i]
+    
+    def __del__(self):
+        # Free the C array when Python object is garbage collected
+        if hasattr(self, '_ptr') and self._ptr:
+            _lib.symbol_array_free(self._ptr)
+            self._ptr = None
+
+
 def _convert_symbol_array(ptr: ctypes.POINTER(_Symbol), count: int) -> list[Symbol]:
     if not ptr or count <= 0:
         return []
@@ -216,9 +319,21 @@ def _convert_symbol_array(ptr: ctypes.POINTER(_Symbol), count: int) -> list[Symb
         _lib.symbol_array_free(ptr)
 
 
-class SymbolDatabase:
-    """Main class for code intelligence operations."""
+def _convert_symbol_array_lazy(ptr: ctypes.POINTER(_Symbol), count: int) -> SymbolArrayView:
+    """Convert C symbol array to a lazy Python view without immediate copying."""
+    if not ptr or count <= 0:
+        if ptr:
+            _lib.symbol_array_free(ptr)  # Free empty array
+        return SymbolArrayView(None, 0)
+    
+    return SymbolArrayView(ptr, count)
+
+
+
+# --- Backend Implementations ---
 
+class _BaseSymbolDatabase:
+    """Base class for code intelligence operations (not for direct use)."""
     def __init__(self):
         self._handle = _lib.symbol_db_create()
         if not self._handle:
@@ -229,6 +344,19 @@ class SymbolDatabase:
             _lib.symbol_db_destroy(self._handle)
             self._handle = None
 
+    def clear(self, *, reuse_memory: bool = True):
+        """Reset the database state while keeping the same Python object.
+
+        Frees the current native database state and reinitializes it. Any
+        previously scanned files, symbols, and project root are discarded.
+        
+        Args:
+            reuse_memory: If True (default), keep allocated arena memory for reuse.
+                         If False, free all memory and start fresh.
+        """
+        if self._handle:
+            _lib.symbol_db_clear(self._handle, ctypes.c_int(1 if reuse_memory else 0))
+
     def set_project_root(self, path: Path_Like):
         _lib.symbol_db_set_project_root(self._handle, os.fsencode(path))
 
@@ -251,9 +379,6 @@ class SymbolDatabase:
         )
 
     def init_project(self, files_by_language: dict[Language, list[Path_Like]]) -> bool:
-        """Batch scan once per language, then rely on update_file for changes.
-        Returns True if all scans succeed.
-        """
         all_ok = True
         for lang, files in files_by_language.items():
             if not files:
@@ -276,6 +401,20 @@ class SymbolDatabase:
             int(language),
         )
 
+    def get_symbol(self, path: Path_Like, line: int, column: int) -> Symbol | None:
+        out = _Symbol()
+        ok = _lib.symbol_db_get_symbol(
+            self._handle,
+            os.fsencode(path),
+            ctypes.c_uint32(line),
+            ctypes.c_uint32(column),
+            ctypes.byref(out),
+        )
+        return _to_py_symbol(out) if ok else None
+
+
+class ImmideateSymbolDatabase(_BaseSymbolDatabase):
+    """Symbol database using copying (eager) backend."""
     def find_definitions(self, symbol_name: str) -> list[Symbol]:
         count = ctypes.c_uint32(0)
         ptr = _lib.symbol_db_find_definitions(
@@ -285,7 +424,6 @@ class SymbolDatabase:
         )
         return _convert_symbol_array(ptr, int(count.value))
 
-    # Alias for backward compatibility with TASK.md API
     def find_symbols(self, symbol_name: str) -> list[Symbol]:
         return self.find_definitions(symbol_name)
 
@@ -303,14 +441,32 @@ class SymbolDatabase:
         ptr = _lib.symbol_db_get_all_symbols(self._handle, ctypes.byref(count))
         return _convert_symbol_array(ptr, int(count.value))
 
-    def get_symbol(self, path: Path_Like, line: int, column: int) -> Symbol | None:
-        """Get symbol at location, returning the resolved definition symbol."""
-        out = _Symbol()
-        ok = _lib.symbol_db_get_symbol(
+
+class LazySymbolDatabase(_BaseSymbolDatabase):
+    """Symbol database using lazy backend."""
+    def find_definitions(self, symbol_name: str) -> SymbolArrayView:
+        count = ctypes.c_uint32(0)
+        ptr = _lib.symbol_db_find_definitions(
             self._handle,
-            os.fsencode(path),
-            ctypes.c_uint32(line),
-            ctypes.c_uint32(column),
-            ctypes.byref(out),
+            symbol_name.encode("utf-8"),
+            ctypes.byref(count),
         )
-        return _to_py_symbol(out) if ok else None
+        return _convert_symbol_array_lazy(ptr, int(count.value))
+
+    def find_symbols(self, symbol_name: str) -> SymbolArrayView:
+        return self.find_definitions(symbol_name)
+
+    def find_references(self, symbol_name: str) -> SymbolArrayView:
+        count = ctypes.c_uint32(0)
+        ptr = _lib.symbol_db_find_references(
+            self._handle,
+            symbol_name.encode("utf-8"),
+            ctypes.byref(count),
+        )
+        return _convert_symbol_array_lazy(ptr, int(count.value))
+
+    def get_all_symbols(self) -> SymbolArrayView:
+        count = ctypes.c_uint32(0)
+        ptr = _lib.symbol_db_get_all_symbols(self._handle, ctypes.byref(count))
+        return _convert_symbol_array_lazy(ptr, int(count.value))
+

{code_intelligence-1.0.0.dist-info → code_intelligence-1.2.0.dist-info}/METADATA

@@ -1,4 +1,4 @@
 Metadata-Version: 2.1
 Name: code_intelligence
-Version: 1.0.0
+Version: 1.2.0
 Summary: Code intelligence library

code_intelligence-1.2.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+code_intelligence-1.2.0.dist-info/METADATA,sha256=hKTZsfBd4PDEY2n4goorqCM_HwqJ8figLIksMS0xueE,100
+code_intelligence-1.2.0.dist-info/RECORD,,
+code_intelligence-1.2.0.dist-info/WHEEL,sha256=aD7J6E7Slys9i0J65v6Ehfi0DHYa5rImRhUDp62Iwh0,98
+code_intelligence/__init__.py,sha256=gruQfSmjho6PUbWU7ZW7OZP2KZ1fsvx5Z-9vAwfnM1g,475
+code_intelligence/_code_intelligence.dll,sha256=LNP8bT3rTDsLKrG-1OHbTIdJN7-VNd3MRi0PI2HzHIQ,6474240
+code_intelligence/symdb.py,sha256=r8fkV4YeKKM4Tajr82L389g7Mv4ftMt_K_I7y8LxEZs,15850

code_intelligence-1.0.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-code_intelligence-1.0.0.dist-info/METADATA,sha256=-kVPTwVAKXJdc-nkZrfnQroG87bxbr6gPuMC6EnAdPg,100
-code_intelligence-1.0.0.dist-info/RECORD,,
-code_intelligence-1.0.0.dist-info/WHEEL,sha256=aD7J6E7Slys9i0J65v6Ehfi0DHYa5rImRhUDp62Iwh0,98
-code_intelligence/__init__.py,sha256=24ugVb05tJOwKsb8e8lfsXmWVKLNBx_EgigOj1WmEHM,472
-code_intelligence/_code_intelligence.dll,sha256=Gl-xAufdN5dkwutuasXcWbqbfac1H0bElFp1VRQf1kk,6471680
-code_intelligence/symdb.py,sha256=2DFljllwCiJbgnnFgawzN-18AB0LFXJfA2fVADuFExQ,10482