nogic 0.0.1__py3-none-any.whl

nogic/parsing/types.py

@@ -0,0 +1,80 @@
+"""
+Data classes for extracted code elements.
+"""
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from tree_sitter import Node
+
+
+@dataclass
+class ExtractedFunction:
+    """Extracted function or method information."""
+
+    name: str
+    qualified_name: str
+    start_line: int
+    end_line: int
+    signature: str
+    docstring: str | None = None
+    decorators: list[str] = field(default_factory=list)
+    is_async: bool = False
+    is_method: bool = False
+    class_name: str | None = None
+    parameters: list[str] = field(default_factory=list)
+    return_type: str | None = None
+    source_code: str = ""
+    node: "Node | None" = field(default=None, repr=False)
+
+
+@dataclass
+class ExtractedClass:
+    """Extracted class information."""
+
+    name: str
+    qualified_name: str
+    start_line: int
+    end_line: int
+    docstring: str | None = None
+    decorators: list[str] = field(default_factory=list)
+    bases: list[str] = field(default_factory=list)
+    methods: list[ExtractedFunction] = field(default_factory=list)
+    source_code: str = ""
+    node: "Node | None" = field(default=None, repr=False)
+
+
+@dataclass
+class ExtractedCall:
+    """Extracted function call information."""
+
+    name: str
+    line: int
+    caller_qualified_name: str
+    receiver: str | None = None
+    arguments: list[str] = field(default_factory=list)
+
+
+@dataclass
+class ExtractedImport:
+    """Extracted import statement."""
+
+    module: str
+    name: str | None = None
+    alias: str | None = None
+    is_wildcard: bool = False
+    line: int = 0
+
+
+@dataclass
+class ParseResult:
+    """Container for all extracted elements from a file."""
+
+    file_path: str
+    language: str
+    functions: list[ExtractedFunction] = field(default_factory=list)
+    classes: list[ExtractedClass] = field(default_factory=list)
+    imports: list[ExtractedImport] = field(default_factory=list)
+    calls: list[ExtractedCall] = field(default_factory=list)
+    error: str | None = None

nogic/storage/__init__.py

@@ -0,0 +1,14 @@
+"""
+Storage module for SQLite database operations.
+"""
+
+from .schema import create_schema, SCHEMA_VERSION
+from .symbols import SymbolStorageService
+from .relationships import RelationshipStorageService
+
+__all__ = [
+    "create_schema",
+    "SCHEMA_VERSION",
+    "SymbolStorageService",
+    "RelationshipStorageService",
+]

nogic/storage/relationships.py

@@ -0,0 +1,322 @@
+"""
+Relationship storage service for managing code relationships in SQLite.
+"""
+
+import json
+import sqlite3
+from dataclasses import dataclass
+from typing import Optional
+
+from nogic.parsing.types import ExtractedCall, ExtractedImport, ExtractedClass
+
+
+@dataclass
+class StoredImport:
+    """A file-level import retrieved from the database."""
+
+    id: int
+    source_file_id: int
+    target_file_id: Optional[int]
+    module_name: str
+
+
+@dataclass
+class StoredSymbolImport:
+    """A symbol-level import retrieved from the database."""
+
+    id: int
+    source_file_id: int
+    module_name: str
+    symbol_names: list[str]
+    import_type: str
+    alias: Optional[str]
+    line: Optional[int]
+
+
+@dataclass
+class StoredCall:
+    """A call relationship retrieved from the database."""
+
+    id: int
+    caller_id: str
+    callee_id: Optional[str]
+    callee_name: str
+    call_type: str
+    receiver: Optional[str]
+    line: Optional[int]
+
+
+@dataclass
+class StoredInheritance:
+    """An inheritance relationship retrieved from the database."""
+
+    id: int
+    child_id: str
+    parent_name: str
+    parent_id: Optional[str]
+    type: str
+
+
+class RelationshipStorageService:
+    """Service for storing and querying code relationships."""
+
+    def __init__(self, conn: sqlite3.Connection):
+        self.conn = conn
+        self.conn.row_factory = sqlite3.Row
+
+    # --- Import Storage ---
+
+    def store_import(
+        self,
+        source_file_id: int,
+        imp: ExtractedImport,
+        target_file_id: Optional[int] = None,
+    ) -> None:
+        """Store an import relationship."""
+        # Store file-level import
+        self.conn.execute(
+            """
+            INSERT OR IGNORE INTO imports (source_file_id, target_file_id, module_name)
+            VALUES (?, ?, ?)
+            """,
+            (source_file_id, target_file_id, imp.module),
+        )
+
+        # Determine import type
+        if imp.is_wildcard:
+            import_type = "wildcard"
+            symbol_names = ["*"]
+        elif imp.name:
+            import_type = "named"
+            symbol_names = [imp.name]
+        else:
+            import_type = "namespace"
+            symbol_names = [imp.module.split(".")[-1]]
+
+        # Store symbol-level import
+        self.conn.execute(
+            """
+            INSERT INTO symbol_imports (source_file_id, module_name, symbol_names, import_type, alias, line)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (
+                source_file_id,
+                imp.module,
+                json.dumps(symbol_names),
+                import_type,
+                imp.alias,
+                imp.line,
+            ),
+        )
+
+    def delete_file_imports(self, file_id: int) -> int:
+        """Delete all imports for a file. Returns count deleted."""
+        count1 = self.conn.execute(
+            "DELETE FROM imports WHERE source_file_id = ?", (file_id,)
+        ).rowcount
+        count2 = self.conn.execute(
+            "DELETE FROM symbol_imports WHERE source_file_id = ?", (file_id,)
+        ).rowcount
+        return count1 + count2
+
+    def get_file_imports(self, file_id: int) -> list[StoredImport]:
+        """Get all file-level imports for a file."""
+        rows = self.conn.execute(
+            "SELECT * FROM imports WHERE source_file_id = ?", (file_id,)
+        ).fetchall()
+
+        return [
+            StoredImport(
+                id=row["id"],
+                source_file_id=row["source_file_id"],
+                target_file_id=row["target_file_id"],
+                module_name=row["module_name"],
+            )
+            for row in rows
+        ]
+
+    def get_symbol_imports(self, file_id: int) -> list[StoredSymbolImport]:
+        """Get all symbol-level imports for a file."""
+        rows = self.conn.execute(
+            "SELECT * FROM symbol_imports WHERE source_file_id = ?", (file_id,)
+        ).fetchall()
+
+        return [
+            StoredSymbolImport(
+                id=row["id"],
+                source_file_id=row["source_file_id"],
+                module_name=row["module_name"],
+                symbol_names=json.loads(row["symbol_names"]),
+                import_type=row["import_type"],
+                alias=row["alias"],
+                line=row["line"],
+            )
+            for row in rows
+        ]
+
+    # --- Call Storage ---
+
+    def store_call(
+        self,
+        call: ExtractedCall,
+        caller_symbol_id: str,
+        callee_symbol_id: Optional[str] = None,
+    ) -> None:
+        """Store a call relationship."""
+        # Determine call type
+        if call.receiver:
+            call_type = "method"
+        else:
+            call_type = "function"
+
+        self.conn.execute(
+            """
+            INSERT INTO calls (caller_id, callee_id, callee_name, call_type, receiver, line)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (
+                caller_symbol_id,
+                callee_symbol_id,
+                call.name,
+                call_type,
+                call.receiver,
+                call.line,
+            ),
+        )
+
+    def delete_caller_calls(self, caller_id: str) -> int:
+        """Delete all calls from a specific caller symbol."""
+        cursor = self.conn.execute(
+            "DELETE FROM calls WHERE caller_id = ?", (caller_id,)
+        )
+        return cursor.rowcount
+
+    def delete_file_calls(self, file_id: int) -> int:
+        """Delete all calls from symbols in a file."""
+        cursor = self.conn.execute(
+            """
+            DELETE FROM calls WHERE caller_id IN (
+                SELECT id FROM symbols WHERE file_id = ?
+            )
+            """,
+            (file_id,),
+        )
+        return cursor.rowcount
+
+    def get_calls_from(self, caller_id: str) -> list[StoredCall]:
+        """Get all calls made by a symbol."""
+        rows = self.conn.execute(
+            "SELECT * FROM calls WHERE caller_id = ?", (caller_id,)
+        ).fetchall()
+
+        return [self._row_to_call(row) for row in rows]
+
+    def get_calls_to(self, callee_id: str) -> list[StoredCall]:
+        """Get all calls to a symbol."""
+        rows = self.conn.execute(
+            "SELECT * FROM calls WHERE callee_id = ?", (callee_id,)
+        ).fetchall()
+
+        return [self._row_to_call(row) for row in rows]
+
+    def get_calls_by_name(self, name: str) -> list[StoredCall]:
+        """Get all calls to a function/method by name (including unresolved)."""
+        rows = self.conn.execute(
+            "SELECT * FROM calls WHERE callee_name = ?", (name,)
+        ).fetchall()
+
+        return [self._row_to_call(row) for row in rows]
+
+    def _row_to_call(self, row: sqlite3.Row) -> StoredCall:
+        """Convert a database row to a StoredCall."""
+        return StoredCall(
+            id=row["id"],
+            caller_id=row["caller_id"],
+            callee_id=row["callee_id"],
+            callee_name=row["callee_name"],
+            call_type=row["call_type"],
+            receiver=row["receiver"],
+            line=row["line"],
+        )
+
+    # --- Inheritance Storage ---
+
+    def store_inheritance(
+        self,
+        child_symbol_id: str,
+        cls: ExtractedClass,
+        parent_symbol_ids: Optional[dict[str, str]] = None,
+    ) -> None:
+        """Store inheritance relationships for a class."""
+        parent_symbol_ids = parent_symbol_ids or {}
+
+        for base_name in cls.bases:
+            parent_id = parent_symbol_ids.get(base_name)
+
+            self.conn.execute(
+                """
+                INSERT INTO inheritance (child_id, parent_name, parent_id, type)
+                VALUES (?, ?, ?, ?)
+                """,
+                (
+                    child_symbol_id,
+                    base_name,
+                    parent_id,
+                    "extends",  # Python only has extends, not implements
+                ),
+            )
+
+    def delete_child_inheritance(self, child_id: str) -> int:
+        """Delete all inheritance relationships for a child class."""
+        cursor = self.conn.execute(
+            "DELETE FROM inheritance WHERE child_id = ?", (child_id,)
+        )
+        return cursor.rowcount
+
+    def delete_file_inheritance(self, file_id: int) -> int:
+        """Delete all inheritance relationships for classes in a file."""
+        cursor = self.conn.execute(
+            """
+            DELETE FROM inheritance WHERE child_id IN (
+                SELECT id FROM symbols WHERE file_id = ? AND kind = 'class'
+            )
+            """,
+            (file_id,),
+        )
+        return cursor.rowcount
+
+    def get_class_parents(self, child_id: str) -> list[StoredInheritance]:
+        """Get all parent classes for a class."""
+        rows = self.conn.execute(
+            "SELECT * FROM inheritance WHERE child_id = ?", (child_id,)
+        ).fetchall()
+
+        return [self._row_to_inheritance(row) for row in rows]
+
+    def get_class_children(self, parent_id: str) -> list[StoredInheritance]:
+        """Get all child classes for a class."""
+        rows = self.conn.execute(
+            "SELECT * FROM inheritance WHERE parent_id = ?", (parent_id,)
+        ).fetchall()
+
+        return [self._row_to_inheritance(row) for row in rows]
+
+    def _row_to_inheritance(self, row: sqlite3.Row) -> StoredInheritance:
+        """Convert a database row to a StoredInheritance."""
+        return StoredInheritance(
+            id=row["id"],
+            child_id=row["child_id"],
+            parent_name=row["parent_name"],
+            parent_id=row["parent_id"],
+            type=row["type"],
+        )
+
+    # --- Bulk Operations ---
+
+    def delete_all_file_relationships(self, file_id: int) -> dict[str, int]:
+        """Delete all relationships for a file. Returns counts by type."""
+        return {
+            "imports": self.delete_file_imports(file_id),
+            "calls": self.delete_file_calls(file_id),
+            "inheritance": self.delete_file_inheritance(file_id),
+        }

nogic/storage/schema.py

@@ -0,0 +1,154 @@
+"""
+Database schema for local code intelligence storage.
+"""
+
+import sqlite3
+
+SCHEMA_VERSION = 2  # Increment when schema changes
+
+
+def create_schema(conn: sqlite3.Connection) -> None:
+    """Create all database tables for code intelligence storage."""
+    conn.executescript(
+        """
+        -- Schema version tracking
+        CREATE TABLE IF NOT EXISTS schema_version (
+            version INTEGER PRIMARY KEY
+        );
+
+        -- Files table (already exists in watcher/storage.py, but included for completeness)
+        CREATE TABLE IF NOT EXISTS files (
+            id INTEGER PRIMARY KEY,
+            path TEXT UNIQUE NOT NULL,
+            content_hash TEXT NOT NULL,
+            last_modified REAL NOT NULL,
+            synced_at REAL,
+            status TEXT NOT NULL DEFAULT 'active'
+        );
+
+        -- Sync events table (already exists)
+        CREATE TABLE IF NOT EXISTS sync_events (
+            id INTEGER PRIMARY KEY,
+            file_id INTEGER NOT NULL,
+            event_type TEXT NOT NULL,
+            content_hash TEXT NOT NULL,
+            timestamp REAL NOT NULL,
+            FOREIGN KEY (file_id) REFERENCES files(id)
+        );
+
+        -- Symbols table (unified for all types: class, function, method, variable)
+        CREATE TABLE IF NOT EXISTS symbols (
+            id TEXT PRIMARY KEY,           -- "path/file.py::ClassName::method"
+            name TEXT NOT NULL,
+            file_id INTEGER NOT NULL,
+            kind TEXT NOT NULL,            -- class/function/method/variable/etc
+            parent_symbol_id TEXT,         -- For methods: their class symbol id
+            exported INTEGER DEFAULT 0,
+            line_start INTEGER,
+            line_end INTEGER,
+            signature TEXT,
+            docstring TEXT,
+            extra_data TEXT,               -- JSON for decorators, params, etc
+            FOREIGN KEY (file_id) REFERENCES files(id) ON DELETE CASCADE,
+            FOREIGN KEY (parent_symbol_id) REFERENCES symbols(id) ON DELETE CASCADE
+        );
+
+        -- File-level imports (which files import which)
+        CREATE TABLE IF NOT EXISTS imports (
+            id INTEGER PRIMARY KEY,
+            source_file_id INTEGER NOT NULL,
+            target_file_id INTEGER,        -- NULL if external module
+            module_name TEXT NOT NULL,     -- The imported module path
+            UNIQUE(source_file_id, module_name),
+            FOREIGN KEY (source_file_id) REFERENCES files(id) ON DELETE CASCADE,
+            FOREIGN KEY (target_file_id) REFERENCES files(id) ON DELETE CASCADE
+        );
+
+        -- Symbol-level imports (what symbols are imported from where)
+        CREATE TABLE IF NOT EXISTS symbol_imports (
+            id INTEGER PRIMARY KEY,
+            source_file_id INTEGER NOT NULL,
+            module_name TEXT NOT NULL,
+            symbol_names TEXT NOT NULL,    -- JSON array of imported symbol names
+            import_type TEXT NOT NULL,     -- 'named', 'default', 'wildcard', 'namespace'
+            alias TEXT,                    -- Alias if renamed
+            line INTEGER,
+            FOREIGN KEY (source_file_id) REFERENCES files(id) ON DELETE CASCADE
+        );
+
+        -- Call edges (function/method calls)
+        CREATE TABLE IF NOT EXISTS calls (
+            id INTEGER PRIMARY KEY,
+            caller_id TEXT NOT NULL,       -- Symbol id of the caller
+            callee_id TEXT,                -- Symbol id of callee (NULL if unresolved)
+            callee_name TEXT NOT NULL,     -- Name of the called function/method
+            call_type TEXT NOT NULL,       -- 'function', 'method', 'constructor'
+            receiver TEXT,                 -- For method calls: the receiver expression
+            line INTEGER,
+            FOREIGN KEY (caller_id) REFERENCES symbols(id) ON DELETE CASCADE,
+            FOREIGN KEY (callee_id) REFERENCES symbols(id) ON DELETE SET NULL
+        );
+
+        -- Inheritance relationships
+        CREATE TABLE IF NOT EXISTS inheritance (
+            id INTEGER PRIMARY KEY,
+            child_id TEXT NOT NULL,        -- Symbol id of the child class
+            parent_name TEXT NOT NULL,     -- Name of the parent (may be unresolved)
+            parent_id TEXT,                -- Symbol id of parent (NULL if external)
+            type TEXT NOT NULL,            -- 'extends' or 'implements'
+            FOREIGN KEY (child_id) REFERENCES symbols(id) ON DELETE CASCADE,
+            FOREIGN KEY (parent_id) REFERENCES symbols(id) ON DELETE SET NULL
+        );
+
+        -- Indexes for efficient querying
+        CREATE INDEX IF NOT EXISTS idx_files_path ON files(path);
+        CREATE INDEX IF NOT EXISTS idx_files_status ON files(status);
+        CREATE INDEX IF NOT EXISTS idx_symbols_file_id ON symbols(file_id);
+        CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
+        CREATE INDEX IF NOT EXISTS idx_symbols_kind ON symbols(kind);
+        CREATE INDEX IF NOT EXISTS idx_symbols_parent ON symbols(parent_symbol_id);
+        CREATE INDEX IF NOT EXISTS idx_imports_source ON imports(source_file_id);
+        CREATE INDEX IF NOT EXISTS idx_imports_target ON imports(target_file_id);
+        CREATE INDEX IF NOT EXISTS idx_symbol_imports_source ON symbol_imports(source_file_id);
+        CREATE INDEX IF NOT EXISTS idx_calls_caller ON calls(caller_id);
+        CREATE INDEX IF NOT EXISTS idx_calls_callee ON calls(callee_id);
+        CREATE INDEX IF NOT EXISTS idx_calls_name ON calls(callee_name);
+        CREATE INDEX IF NOT EXISTS idx_inheritance_child ON inheritance(child_id);
+        CREATE INDEX IF NOT EXISTS idx_inheritance_parent ON inheritance(parent_id);
+    """
+    )
+
+
+def get_schema_version(conn: sqlite3.Connection) -> int:
+    """Get the current schema version from database."""
+    try:
+        cursor = conn.execute("SELECT version FROM schema_version LIMIT 1")
+        row = cursor.fetchone()
+        return row[0] if row else 0
+    except sqlite3.OperationalError:
+        return 0
+
+
+def set_schema_version(conn: sqlite3.Connection, version: int) -> None:
+    """Set the schema version in database."""
+    conn.execute("DELETE FROM schema_version")
+    conn.execute("INSERT INTO schema_version (version) VALUES (?)", (version,))
+    conn.commit()
+
+
+def migrate_schema(conn: sqlite3.Connection) -> bool:
+    """
+    Migrate schema to latest version if needed.
+    Returns True if migration was performed.
+    """
+    current_version = get_schema_version(conn)
+
+    if current_version >= SCHEMA_VERSION:
+        return False
+
+    # For now, we recreate schema on version mismatch
+    # In production, you'd want proper migrations
+    create_schema(conn)
+    set_schema_version(conn, SCHEMA_VERSION)
+
+    return True