nogic 0.0.1__py3-none-any.whl

nogic/storage/symbols.py

@@ -0,0 +1,203 @@
+"""
+Symbol storage service for managing code symbols in SQLite.
+"""
+
+import json
+import sqlite3
+from dataclasses import dataclass
+from typing import Optional
+
+from nogic.parsing.types import ExtractedFunction, ExtractedClass
+
+
+@dataclass
+class StoredSymbol:
+    """A symbol retrieved from the database."""
+
+    id: str
+    name: str
+    file_id: int
+    kind: str
+    parent_symbol_id: Optional[str]
+    exported: bool
+    line_start: Optional[int]
+    line_end: Optional[int]
+    signature: Optional[str]
+    docstring: Optional[str]
+    extra_data: Optional[dict]
+
+
+class SymbolStorageService:
+    """Service for storing and querying code symbols."""
+
+    def __init__(self, conn: sqlite3.Connection):
+        self.conn = conn
+        self.conn.row_factory = sqlite3.Row
+
+    def _make_symbol_id(
+        self, file_path: str, name: str, parent_name: Optional[str] = None
+    ) -> str:
+        """Create a unique symbol ID from file path and names."""
+        if parent_name:
+            return f"{file_path}::{parent_name}::{name}"
+        return f"{file_path}::{name}"
+
+    def store_function(
+        self,
+        file_id: int,
+        file_path: str,
+        func: ExtractedFunction,
+        parent_symbol_id: Optional[str] = None,
+    ) -> str:
+        """Store a function or method symbol. Returns the symbol ID."""
+        if func.class_name:
+            symbol_id = self._make_symbol_id(file_path, func.name, func.class_name)
+            kind = "method"
+        else:
+            symbol_id = self._make_symbol_id(file_path, func.name)
+            kind = "function"
+
+        extra_data = {
+            "decorators": func.decorators,
+            "parameters": func.parameters,
+            "return_type": func.return_type,
+            "is_async": func.is_async,
+        }
+
+        self.conn.execute(
+            """
+            INSERT OR REPLACE INTO symbols
+            (id, name, file_id, kind, parent_symbol_id, exported, line_start, line_end, signature, docstring, extra_data)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                symbol_id,
+                func.name,
+                file_id,
+                kind,
+                parent_symbol_id,
+                0,  # exported - would need export detection
+                func.start_line,
+                func.end_line,
+                func.signature,
+                func.docstring,
+                json.dumps(extra_data),
+            ),
+        )
+
+        return symbol_id
+
+    def store_class(
+        self,
+        file_id: int,
+        file_path: str,
+        cls: ExtractedClass,
+    ) -> str:
+        """Store a class symbol and its methods. Returns the class symbol ID."""
+        symbol_id = self._make_symbol_id(file_path, cls.name)
+
+        extra_data = {
+            "decorators": cls.decorators,
+            "bases": cls.bases,
+        }
+
+        self.conn.execute(
+            """
+            INSERT OR REPLACE INTO symbols
+            (id, name, file_id, kind, parent_symbol_id, exported, line_start, line_end, signature, docstring, extra_data)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                symbol_id,
+                cls.name,
+                file_id,
+                "class",
+                None,
+                0,  # exported
+                cls.start_line,
+                cls.end_line,
+                f"class {cls.name}",
+                cls.docstring,
+                json.dumps(extra_data),
+            ),
+        )
+
+        # Store methods with parent reference
+        for method in cls.methods:
+            self.store_function(file_id, file_path, method, parent_symbol_id=symbol_id)
+
+        return symbol_id
+
+    def delete_file_symbols(self, file_id: int) -> int:
+        """Delete all symbols for a file. Returns count deleted."""
+        cursor = self.conn.execute(
+            "DELETE FROM symbols WHERE file_id = ?", (file_id,)
+        )
+        return cursor.rowcount
+
+    def get_symbol(self, symbol_id: str) -> Optional[StoredSymbol]:
+        """Get a symbol by ID."""
+        row = self.conn.execute(
+            "SELECT * FROM symbols WHERE id = ?", (symbol_id,)
+        ).fetchone()
+
+        if not row:
+            return None
+
+        return self._row_to_symbol(row)
+
+    def get_symbols_by_file(self, file_id: int) -> list[StoredSymbol]:
+        """Get all symbols in a file."""
+        rows = self.conn.execute(
+            "SELECT * FROM symbols WHERE file_id = ?", (file_id,)
+        ).fetchall()
+
+        return [self._row_to_symbol(row) for row in rows]
+
+    def get_symbols_by_name(self, name: str) -> list[StoredSymbol]:
+        """Get all symbols with a given name."""
+        rows = self.conn.execute(
+            "SELECT * FROM symbols WHERE name = ?", (name,)
+        ).fetchall()
+
+        return [self._row_to_symbol(row) for row in rows]
+
+    def get_symbols_by_kind(self, kind: str) -> list[StoredSymbol]:
+        """Get all symbols of a given kind (class, function, method)."""
+        rows = self.conn.execute(
+            "SELECT * FROM symbols WHERE kind = ?", (kind,)
+        ).fetchall()
+
+        return [self._row_to_symbol(row) for row in rows]
+
+    def search_symbols(self, query: str, limit: int = 50) -> list[StoredSymbol]:
+        """Search symbols by name pattern."""
+        rows = self.conn.execute(
+            "SELECT * FROM symbols WHERE name LIKE ? LIMIT ?",
+            (f"%{query}%", limit),
+        ).fetchall()
+
+        return [self._row_to_symbol(row) for row in rows]
+
+    def _row_to_symbol(self, row: sqlite3.Row) -> StoredSymbol:
+        """Convert a database row to a StoredSymbol."""
+        extra_data = None
+        if row["extra_data"]:
+            try:
+                extra_data = json.loads(row["extra_data"])
+            except json.JSONDecodeError:
+                pass
+
+        return StoredSymbol(
+            id=row["id"],
+            name=row["name"],
+            file_id=row["file_id"],
+            kind=row["kind"],
+            parent_symbol_id=row["parent_symbol_id"],
+            exported=bool(row["exported"]),
+            line_start=row["line_start"],
+            line_end=row["line_end"],
+            signature=row["signature"],
+            docstring=row["docstring"],
+            extra_data=extra_data,
+        )

nogic/telemetry.py

@@ -0,0 +1,142 @@
+"""Telemetry module for Nogic CLI — sends events to backend telemetry endpoints."""
+
+import hashlib
+import json
+import os
+import platform
+from pathlib import Path
+
+import httpx
+
+from nogic import __version__
+from .config import GLOBAL_CONFIG_DIR, CONFIG_FILE
+
+_client: httpx.Client | None = None
+_disabled: bool = False
+
+
+def _get_api_url() -> str:
+    """Get the backend API URL from config."""
+    from .config import Config
+
+    config = Config.load()
+    return config.api_url
+
+
+def _get_anonymous_id() -> str:
+    """Get anonymous ID based on API key (if logged in) or machine."""
+    from .config import Config
+
+    config = Config.load()
+
+    if config.api_key:
+        return hashlib.sha256(config.api_key.encode()).hexdigest()[:16]
+
+    try:
+        login = os.getlogin()
+    except OSError:
+        login = os.getenv("USER", os.getenv("USERNAME", "unknown"))
+    machine_info = f"{platform.node()}-{platform.machine()}-{login}"
+    return hashlib.sha256(machine_info.encode()).hexdigest()[:16]
+
+
+def _is_telemetry_enabled() -> bool:
+    """Check if telemetry is enabled (opt-out via env var or config)."""
+    if os.getenv("NOGIC_TELEMETRY_DISABLED", "").lower() in ("1", "true", "yes"):
+        return False
+    if os.getenv("DO_NOT_TRACK", "").lower() in ("1", "true", "yes"):
+        return False
+
+    config_file = GLOBAL_CONFIG_DIR / CONFIG_FILE
+    if config_file.exists():
+        try:
+            with open(config_file, encoding="utf-8") as f:
+                data = json.load(f)
+                if data.get("telemetry_enabled") is False:
+                    return False
+        except (json.JSONDecodeError, OSError):
+            pass
+    return True
+
+
+def _get_client() -> httpx.Client | None:
+    """Get or create the httpx client. Returns None if telemetry is disabled."""
+    global _client, _disabled
+    if _disabled:
+        return None
+
+    if not _is_telemetry_enabled():
+        _disabled = True
+        return None
+
+    if _client is None:
+        _client = httpx.Client(timeout=5.0)
+
+    return _client
+
+
+def capture(event: str, properties: dict | None = None):
+    """Capture a telemetry event by sending it to the backend."""
+    client = _get_client()
+    if client is None:
+        return
+
+    try:
+        props = properties or {}
+        props.update({
+            "cli_version": __version__,
+            "os": platform.system(),
+            "os_version": platform.release(),
+            "python_version": platform.python_version(),
+        })
+
+        api_url = _get_api_url()
+        client.post(
+            f"{api_url}/v1/telemetry",
+            json={
+                "event": event,
+                "properties": props,
+                "anonymous_id": _get_anonymous_id(),
+            },
+        )
+    except Exception:
+        pass
+
+
+def identify(user_id: str | None = None, properties: dict | None = None):
+    """Identify a user by sending to the backend."""
+    client = _get_client()
+    if client is None:
+        return
+
+    if not user_id:
+        return
+
+    try:
+        hashed_user_id = hashlib.sha256(user_id.encode()).hexdigest()[:16]
+
+        props = properties or {}
+        props.update({"os": platform.system()})
+
+        api_url = _get_api_url()
+        client.post(
+            f"{api_url}/v1/telemetry/identify",
+            json={
+                "anonymous_id": _get_anonymous_id(),
+                "user_id": hashed_user_id,
+                "properties": props,
+            },
+        )
+    except Exception:
+        pass
+
+
+def shutdown():
+    """Close the HTTP client."""
+    global _client
+    if _client is not None:
+        try:
+            _client.close()
+        except Exception:
+            pass
+        _client = None

nogic/ui.py

@@ -0,0 +1,60 @@
+"""CLI output styling utilities."""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.rule import Rule
+
+console = Console()
+error_console = Console(stderr=True)
+
+
+def banner(title: str, subtitle: str | None = None):
+    """Display a styled command header."""
+    console.print()
+    console.print(Rule(f"[bold cyan]{title}[/]", style="dim"))
+    if subtitle:
+        dim(f"  {subtitle}")
+
+
+def dev_banner(url: str):
+    """Display dev mode warning."""
+    console.print(Panel(
+        f"[yellow bold]DEV MODE[/] Using {url}",
+        border_style="yellow",
+        padding=(0, 1),
+    ))
+
+
+def success(msg: str):
+    console.print(f"[green bold]>[/] {msg}")
+
+
+def info(msg: str):
+    console.print(f"[blue]>[/] {msg}")
+
+
+def warn(msg: str):
+    console.print(f"[yellow bold]![/] {msg}")
+
+
+def error(msg: str):
+    error_console.print(f"[red bold]![/] {msg}")
+
+
+def dim(msg: str):
+    console.print(f"[dim]{msg}[/]")
+
+
+def kv(key: str, value: str, indent: int = 2):
+    """Print a key-value pair."""
+    pad = " " * indent
+    console.print(f"{pad}[dim]{key}:[/] {value}")
+
+
+def section(title: str):
+    console.print(f"\n[bold]{title}[/]")
+
+
+def status_spinner(msg: str):
+    """Return a Rich status context manager for spinners."""
+    return console.status(f"[dim]{msg}[/]", spinner="dots")

nogic/watcher/__init__.py

@@ -0,0 +1,7 @@
+"""File watcher module for syncing files."""
+
+from nogic.watcher.storage import FileStorage
+from nogic.watcher.monitor import FileMonitor
+from nogic.watcher.sync import SyncService
+
+__all__ = ["FileStorage", "FileMonitor", "SyncService"]

nogic/watcher/monitor.py

@@ -0,0 +1,80 @@
+"""File system monitoring with watchdog."""
+
+from pathlib import Path
+from typing import Callable
+
+from watchdog.observers import Observer
+from watchdog.events import (
+    FileSystemEventHandler,
+    FileCreatedEvent,
+    FileModifiedEvent,
+    FileDeletedEvent,
+    FileMovedEvent,
+)
+
+__all__ = ["FileEventHandler", "FileMonitor"]
+
+
+class FileEventHandler(FileSystemEventHandler):
+    def __init__(
+        self,
+        on_change: Callable[[Path], None],
+        on_delete: Callable[[Path], None],
+        should_ignore: Callable[[Path], bool],
+    ):
+        self.on_change = on_change
+        self.on_delete = on_delete
+        self.should_ignore = should_ignore
+
+    def _handle_change(self, path: Path):
+        if path.is_file() and not self.should_ignore(path):
+            self.on_change(path)
+
+    def _handle_delete(self, path: Path):
+        if not self.should_ignore(path):
+            self.on_delete(path)
+
+    def on_created(self, event: FileCreatedEvent):
+        if not event.is_directory:
+            self._handle_change(Path(event.src_path))
+
+    def on_modified(self, event: FileModifiedEvent):
+        if not event.is_directory:
+            self._handle_change(Path(event.src_path))
+
+    def on_deleted(self, event: FileDeletedEvent):
+        if not event.is_directory:
+            self._handle_delete(Path(event.src_path))
+
+    def on_moved(self, event: FileMovedEvent):
+        if not event.is_directory:
+            self._handle_delete(Path(event.src_path))
+            self._handle_change(Path(event.dest_path))
+
+
+class FileMonitor:
+    def __init__(
+        self,
+        root_path: Path,
+        on_change: Callable[[Path], None],
+        on_delete: Callable[[Path], None],
+        should_ignore: Callable[[Path], bool],
+    ):
+        self.root_path = root_path.resolve()
+        self.handler = FileEventHandler(
+            on_change=on_change,
+            on_delete=on_delete,
+            should_ignore=should_ignore,
+        )
+        self.observer = Observer()
+
+    def start(self):
+        self.observer.schedule(self.handler, str(self.root_path), recursive=True)
+        self.observer.start()
+
+    def stop(self):
+        self.observer.stop()
+        self.observer.join(timeout=5)
+
+    def is_alive(self) -> bool:
+        return self.observer.is_alive()

nogic/watcher/storage.py

@@ -0,0 +1,185 @@
+"""SQLite storage layer for file tracking."""
+
+import os
+import sqlite3
+import hashlib
+from pathlib import Path
+from dataclasses import dataclass
+from typing import Optional
+import time
+
+from nogic.storage.schema import (
+    create_schema,
+    get_schema_version,
+    set_schema_version,
+    migrate_schema,
+    SCHEMA_VERSION,
+)
+
+
+@dataclass
+class FileRecord:
+    id: int
+    path: str
+    content_hash: str
+    last_modified: float
+    synced_at: Optional[float]
+    status: str  # 'active' or 'deleted'
+
+
+class FileStorage:
+    def __init__(self, db_path: Path):
+        self.db_path = db_path
+        self._conn: Optional[sqlite3.Connection] = None
+        self._init_db()
+
+    def _init_db(self):
+        conn = self._connect()
+        current_version = get_schema_version(conn)
+
+        if current_version < SCHEMA_VERSION:
+            create_schema(conn)
+            set_schema_version(conn, SCHEMA_VERSION)
+            conn.commit()
+
+        # Restrict database file permissions
+        os.chmod(self.db_path, 0o600)
+
+    def _connect(self) -> sqlite3.Connection:
+        """Return the shared connection, creating it if needed."""
+        if self._conn is None:
+            self._conn = sqlite3.connect(self.db_path)
+            self._conn.row_factory = sqlite3.Row
+        return self._conn
+
+    def close(self):
+        """Close the database connection."""
+        if self._conn is not None:
+            self._conn.close()
+            self._conn = None
+
+    @staticmethod
+    def compute_hash(content: str) -> str:
+        return hashlib.sha256(content.encode()).hexdigest()
+
+    def get_file(self, path: str) -> Optional[FileRecord]:
+        conn = self._connect()
+        row = conn.execute(
+            "SELECT * FROM files WHERE path = ?", (path,)
+        ).fetchone()
+        if row:
+            return FileRecord(**dict(row))
+        return None
+
+    def upsert_file(
+        self, path: str, content_hash: str, last_modified: float
+    ) -> tuple[int, str]:
+        """Insert or update file. Returns (file_id, event_type)."""
+        existing = self.get_file(path)
+        now = time.time()
+
+        conn = self._connect()
+        if existing is None:
+            cursor = conn.execute(
+                """INSERT INTO files (path, content_hash, last_modified, status)
+                   VALUES (?, ?, ?, 'active')""",
+                (path, content_hash, last_modified),
+            )
+            file_id = cursor.lastrowid
+            event_type = "created"
+        elif existing.status == "deleted":
+            conn.execute(
+                """UPDATE files
+                   SET content_hash = ?, last_modified = ?, status = 'active'
+                   WHERE id = ?""",
+                (content_hash, last_modified, existing.id),
+            )
+            file_id = existing.id
+            event_type = "created"
+        elif existing.content_hash != content_hash:
+            conn.execute(
+                """UPDATE files
+                   SET content_hash = ?, last_modified = ?
+                   WHERE id = ?""",
+                (content_hash, last_modified, existing.id),
+            )
+            file_id = existing.id
+            event_type = "modified"
+        else:
+            return existing.id, "unchanged"
+
+        conn.execute(
+            """INSERT INTO sync_events (file_id, event_type, content_hash, timestamp)
+               VALUES (?, ?, ?, ?)""",
+            (file_id, event_type, content_hash, now),
+        )
+        conn.commit()
+        return file_id, event_type
+
+    def mark_deleted(self, path: str) -> Optional[int]:
+        """Mark file as deleted. Returns file_id if found."""
+        existing = self.get_file(path)
+        if existing and existing.status == "active":
+            now = time.time()
+            conn = self._connect()
+            conn.execute(
+                "UPDATE files SET status = 'deleted' WHERE id = ?",
+                (existing.id,),
+            )
+            conn.execute(
+                """INSERT INTO sync_events (file_id, event_type, content_hash, timestamp)
+                   VALUES (?, 'deleted', ?, ?)""",
+                (existing.id, existing.content_hash, now),
+            )
+            conn.commit()
+            return existing.id
+        return None
+
+    def mark_synced(self, file_id: int):
+        """Mark file as synced."""
+        conn = self._connect()
+        conn.execute(
+            "UPDATE files SET synced_at = ? WHERE id = ?",
+            (time.time(), file_id),
+        )
+        conn.commit()
+
+    def get_pending_sync(self) -> list[FileRecord]:
+        """Get files that need syncing (modified after last sync)."""
+        conn = self._connect()
+        rows = conn.execute(
+            """SELECT * FROM files
+               WHERE status = 'active'
+               AND (synced_at IS NULL OR last_modified > synced_at)"""
+        ).fetchall()
+        return [FileRecord(**dict(row)) for row in rows]
+
+    def get_all_active(self) -> list[FileRecord]:
+        """Get all active files."""
+        conn = self._connect()
+        rows = conn.execute(
+            "SELECT * FROM files WHERE status = 'active'"
+        ).fetchall()
+        return [FileRecord(**dict(row)) for row in rows]
+
+    def get_stats(self) -> dict:
+        """Get storage statistics."""
+        conn = self._connect()
+        total = conn.execute(
+            "SELECT COUNT(*) FROM files WHERE status = 'active'"
+        ).fetchone()[0]
+        synced = conn.execute(
+            "SELECT COUNT(*) FROM files WHERE status = 'active' AND synced_at IS NOT NULL"
+        ).fetchone()[0]
+        return {
+            "total_files": total,
+            "synced_files": synced,
+            "pending_files": total - synced,
+        }
+
+    def clear_all(self):
+        """Clear all file records (for reindexing)."""
+        conn = self._connect()
+        conn.execute("DELETE FROM sync_events")
+        conn.execute("DELETE FROM files")
+        conn.commit()