from navegador.graph import GraphStore
from navegador.context import ContextLoader, ContextBundle, ContextNode, ContextEdge
from navegador.ingest import RepoIngester, KnowledgeIngester, WikiIngester, PlanopticonIngester

class GraphStore:
    @classmethod
    def sqlite(cls, path: str | Path = "navegador.db") -> "GraphStore": ...

    @classmethod
    def redis(cls, url: str = "redis://localhost:6379") -> "GraphStore": ...

@classmethod
def sqlite(cls, path: str | Path = "navegador.db") -> "GraphStore"

@classmethod
def redis(cls, url: str = "redis://localhost:6379") -> "GraphStore"

def query(self, cypher: str, params: dict | None = None) -> list[dict]

def create_node(self, label: str, properties: dict) -> str

def merge_node(
    self,
    label: str,
    match_properties: dict,
    set_properties: dict | None = None,
) -> str

def create_edge(
    self,
    from_id: str,
    to_id: str,
    edge_type: str,
    properties: dict | None = None,
) -> None

def merge_edge(
    self,
    from_label: str,
    from_match: dict,
    to_label: str,
    to_match: dict,
    edge_type: str,
    properties: dict | None = None,
) -> None

def clear(self) -> None

def close(self) -> None

with GraphStore.sqlite(".navegador/navegador.db") as store:
    results = store.query("MATCH (n) RETURN count(n) AS total")

class ContextLoader:
    def __init__(self, store: GraphStore) -> None: ...

def load_file(self, path: str) -> ContextBundle

def load_function(
    self,
    name: str,
    *,
    file: str = "",
    depth: int = 1,
) -> ContextBundle

def load_class(
    self,
    name: str,
    *,
    file: str = "",
) -> ContextBundle

def explain(
    self,
    name: str,
    *,
    file: str = "",
) -> ContextBundle

def load_concept(self, name: str) -> ContextBundle

def load_domain(self, name: str) -> ContextBundle

def search(
    self,
    query: str,
    *,
    all_layers: bool = False,
    docs_only: bool = False,
    limit: int = 20,
) -> list[ContextNode]

def search_by_docstring(self, query: str, *, limit: int = 20) -> list[ContextNode]

def decorated_by(self, decorator: str) -> list[ContextNode]

@dataclass
class ContextBundle:
    root: ContextNode
    nodes: list[ContextNode]
    edges: list[ContextEdge]
    metadata: dict

def to_json(self) -> str

def to_markdown(self) -> str

def to_dict(self) -> dict

@dataclass
class ContextNode:
    id: str
    label: str        # e.g. "Function", "Concept"
    name: str
    properties: dict  # all node properties from the graph
    layer: str        # "code" or "knowledge"
    score: float      # relevance score (search results only)

@dataclass
class ContextEdge:
    from_id: str
    to_id: str
    edge_type: str   # e.g. "CALLS", "ANNOTATES", "INHERITS"
    properties: dict

@dataclass
class IngestionResult:
    nodes_created: int
    nodes_updated: int
    edges_created: int
    files_processed: int
    errors: list[str]
    duration_seconds: float