osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/graph/store.py

@@ -0,0 +1,183 @@
+"""Graph store facade delegating to a pluggable backend."""
+
+from __future__ import annotations
+
+import logging
+import warnings
+from collections.abc import Callable
+from typing import Any
+
+from osscodeiq.graph.backend import CypherBackend, GraphBackend
+from osscodeiq.models.graph import (
+    CodeGraph,
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class GraphStore:
+    """Public API for graph operations. Delegates to a pluggable backend."""
+
+    def __init__(self, backend: GraphBackend | None = None) -> None:
+        if backend is None:
+            from osscodeiq.graph.backends.networkx import NetworkXBackend
+            backend = NetworkXBackend()
+        self._backend: GraphBackend = backend
+
+    @property
+    def graph(self) -> Any:
+        """Deprecated. Direct backend access; only works with NetworkXBackend."""
+        warnings.warn(
+            "GraphStore.graph is deprecated. Use public API methods instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        if hasattr(self._backend, "_g"):
+            return self._backend._g
+        raise AttributeError("Backend does not expose raw graph object")
+
+    @property
+    def node_count(self) -> int:
+        return self._backend.node_count
+
+    @property
+    def edge_count(self) -> int:
+        return self._backend.edge_count
+
+    def add_node(self, node: GraphNode) -> None:
+        self._backend.add_node(node)
+
+    def add_edge(self, edge: GraphEdge) -> None:
+        self._backend.add_edge(edge)
+
+    def get_node(self, node_id: str) -> GraphNode | None:
+        return self._backend.get_node(node_id)
+
+    def get_edges_between(self, source: str, target: str) -> list[GraphEdge]:
+        return self._backend.get_edges_between(source, target)
+
+    def all_nodes(self) -> list[GraphNode]:
+        return self._backend.all_nodes()
+
+    def all_edges(self) -> list[GraphEdge]:
+        return self._backend.all_edges()
+
+    def nodes_by_kind(self, kind: NodeKind) -> list[GraphNode]:
+        return self._backend.nodes_by_kind(kind)
+
+    def edges_by_kind(self, kind: EdgeKind) -> list[GraphEdge]:
+        return self._backend.edges_by_kind(kind)
+
+    def neighbors(
+        self,
+        node_id: str,
+        edge_kinds: set[EdgeKind] | None = None,
+        direction: str = "both",
+    ) -> list[str]:
+        return self._backend.neighbors(node_id, edge_kinds, direction)
+
+    def subgraph(self, node_ids: set[str]) -> GraphStore:
+        return GraphStore(backend=self._backend.subgraph(node_ids))
+
+    def ego(
+        self,
+        center: str,
+        radius: int = 2,
+        edge_kinds: set[EdgeKind] | None = None,
+    ) -> GraphStore:
+        if not self._backend.has_node(center):
+            return GraphStore(backend=type(self._backend)() if callable(type(self._backend)) else None)
+
+        radius = min(radius, 10)
+        visited: set[str] = {center}
+        frontier: set[str] = {center}
+
+        for _ in range(radius):
+            next_frontier: set[str] = set()
+            for node_id in frontier:
+                next_frontier.update(
+                    n for n in self.neighbors(node_id, edge_kinds, "both")
+                    if n not in visited
+                )
+            visited.update(next_frontier)
+            frontier = next_frontier
+
+        return self.subgraph(visited)
+
+    def filter(
+        self,
+        node_filter: Callable[[GraphNode], bool] | None = None,
+        edge_filter: Callable[[GraphEdge], bool] | None = None,
+    ) -> GraphStore:
+        new_store = GraphStore()  # Always uses NetworkX for filtered results
+
+        for node in self.all_nodes():
+            if node_filter is None or node_filter(node):
+                new_store.add_node(node)
+
+        for edge in self.all_edges():
+            if new_store._backend.has_node(edge.source) and new_store._backend.has_node(edge.target):
+                if edge_filter is None or edge_filter(edge):
+                    new_store.add_edge(edge)
+
+        return new_store
+
+    def find_cycles(self, limit: int = 100) -> list[list[str]]:
+        return self._backend.find_cycles(limit)
+
+    def shortest_path(self, source: str, target: str) -> list[str] | None:
+        return self._backend.shortest_path(source, target)
+
+    def update_node_properties(self, node_id: str, properties: dict[str, Any]) -> None:
+        self._backend.update_node_properties(node_id, properties)
+
+    def to_model(self) -> CodeGraph:
+        nodes = self.all_nodes()
+        edges = self.all_edges()
+        node_counts: dict[str, int] = {}
+        for n in nodes:
+            k = n.kind.value
+            node_counts[k] = node_counts.get(k, 0) + 1
+        edge_counts: dict[str, int] = {}
+        for e in edges:
+            k = e.kind.value
+            edge_counts[k] = edge_counts.get(k, 0) + 1
+
+        return CodeGraph(
+            nodes=nodes,
+            edges=edges,
+            metadata={
+                "stats": {
+                    "total_nodes": len(nodes),
+                    "total_edges": len(edges),
+                    "node_counts_by_kind": node_counts,
+                    "edge_counts_by_kind": edge_counts,
+                },
+            },
+        )
+
+    def from_model(self, code_graph: CodeGraph) -> None:
+        self._backend.clear()
+        for node in code_graph.nodes:
+            self._backend.add_node(node)
+        for edge in code_graph.edges:
+            self._backend.add_edge(edge)
+
+    @property
+    def supports_cypher(self) -> bool:
+        return isinstance(self._backend, CypherBackend)
+
+    def query_cypher(self, cypher: str, params: dict[str, Any] | None = None) -> list[dict[str, Any]]:
+        if not isinstance(self._backend, CypherBackend):
+            raise NotImplementedError(
+                f"Backend {type(self._backend).__name__} does not support Cypher. "
+                "Use kuzu, neo4j, or age backend."
+            )
+        return self._backend.query_cypher(cypher, params)
+
+    def close(self) -> None:
+        self._backend.close()

osscodeiq/graph/views.py

@@ -0,0 +1,231 @@
+"""Multi-level view transformations for the OSSCodeIQ graph."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+
+from osscodeiq.config import DomainMapping
+from osscodeiq.graph.store import GraphStore
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+)
+
+
+class ArchitectView:
+    """Collapses detail nodes into module-level nodes.
+
+    Method-level calls, imports, and injections are rolled up into
+    module-level ``depends_on`` edges.  Messaging edges (produces,
+    consumes, publishes, listens) preserve their identity so that
+    data-flow remains visible at the architecture level.
+    """
+
+    EDGE_ROLLUP: dict[EdgeKind, EdgeKind] = {
+        EdgeKind.CALLS: EdgeKind.DEPENDS_ON,
+        EdgeKind.IMPORTS: EdgeKind.DEPENDS_ON,
+        EdgeKind.INJECTS: EdgeKind.DEPENDS_ON,
+        EdgeKind.EXTENDS: EdgeKind.DEPENDS_ON,
+        EdgeKind.IMPLEMENTS: EdgeKind.DEPENDS_ON,
+        EdgeKind.PRODUCES: EdgeKind.PRODUCES,
+        EdgeKind.CONSUMES: EdgeKind.CONSUMES,
+        EdgeKind.PUBLISHES: EdgeKind.PUBLISHES,
+        EdgeKind.LISTENS: EdgeKind.LISTENS,
+        EdgeKind.INVOKES_RMI: EdgeKind.INVOKES_RMI,
+        EdgeKind.EXPORTS_RMI: EdgeKind.EXPORTS_RMI,
+        EdgeKind.DEPENDS_ON: EdgeKind.DEPENDS_ON,
+    }
+
+    def _resolve_module(self, node: GraphNode) -> str | None:
+        """Return the module id that owns *node*.
+
+        MODULE nodes own themselves; every other node uses its
+        ``module`` property.
+        """
+        if node.kind == NodeKind.MODULE:
+            return node.id
+        return node.module
+
+    def roll_up(self, store: GraphStore) -> GraphStore:
+        """Collapse all non-module nodes into their owning module.
+
+        Returns a new :class:`GraphStore` containing only MODULE nodes
+        with rolled-up edges and summary properties.
+        """
+        new_store = GraphStore()
+
+        # --- 1. Collect module nodes and build summary counters --------
+        module_nodes: dict[str, GraphNode] = {}
+        summary: dict[str, dict[str, int]] = defaultdict(lambda: defaultdict(int))
+
+        for node in store.all_nodes():
+            mod_id = self._resolve_module(node)
+            if mod_id is None:
+                continue
+            # Ensure we have a MODULE node entry
+            if mod_id not in module_nodes:
+                existing = store.get_node(mod_id)
+                if existing is not None and existing.kind == NodeKind.MODULE:
+                    module_nodes[mod_id] = existing
+                else:
+                    # Synthesise a module node when one is not present
+                    module_nodes[mod_id] = GraphNode(
+                        id=mod_id,
+                        kind=NodeKind.MODULE,
+                        label=mod_id,
+                    )
+            # Count child node kinds for summary
+            summary[mod_id][node.kind.value] += 1
+
+        # Add module nodes with summary properties
+        for mod_id, mod_node in module_nodes.items():
+            counts = dict(summary.get(mod_id, {}))
+            props = dict(mod_node.properties)
+            props["endpoint_count"] = counts.get(NodeKind.ENDPOINT.value, 0)
+            props["entity_count"] = counts.get(NodeKind.ENTITY.value, 0)
+            props["class_count"] = counts.get(NodeKind.CLASS.value, 0)
+            props["method_count"] = counts.get(NodeKind.METHOD.value, 0)
+            enriched = mod_node.model_copy(update={"properties": props})
+            new_store.add_node(enriched)
+
+        # --- 2. Roll up edges -----------------------------------------
+        # Pre-build node_id -> module_id mapping via public API
+        module_map: dict[str, str | None] = {}
+        for node in store.all_nodes():
+            module_map[node.id] = node.module
+
+        # (source_module, target_module, rolled_kind) -> weight
+        edge_weights: dict[tuple[str, str, EdgeKind], int] = defaultdict(int)
+
+        for edge in store.all_edges():
+            rolled_kind = self.EDGE_ROLLUP.get(edge.kind)
+            if rolled_kind is None:
+                continue
+
+            src_mod = module_map.get(edge.source)
+            tgt_mod = module_map.get(edge.target)
+            if src_mod is None or tgt_mod is None:
+                continue
+            # Skip self-loops at module level
+            if src_mod == tgt_mod:
+                continue
+            # Ensure both modules exist in new store
+            if src_mod not in module_nodes or tgt_mod not in module_nodes:
+                continue
+
+            edge_weights[(src_mod, tgt_mod, rolled_kind)] += 1
+
+        # --- 3. Create merged edges -----------------------------------
+        for (src, tgt, kind), weight in edge_weights.items():
+            props: dict[str, object] = {"weight": weight}
+            new_store.add_edge(
+                GraphEdge(
+                    source=src,
+                    target=tgt,
+                    kind=kind,
+                    label=f"{kind.value} (x{weight})" if weight > 1 else kind.value,
+                    properties=props,
+                )
+            )
+
+        return new_store
+
+
+class DomainView:
+    """Collapses modules into business domain groups.
+
+    Uses :class:`DomainMapping` definitions from the project
+    configuration to merge module-level nodes into domain-level
+    aggregates.
+    """
+
+    def __init__(self, domain_mappings: list[DomainMapping]) -> None:
+        self._mappings = domain_mappings
+        # Pre-build module -> domain lookup
+        self._module_to_domain: dict[str, str] = {}
+        for mapping in domain_mappings:
+            for module in mapping.modules:
+                self._module_to_domain[module] = mapping.name
+
+    def _resolve_domain(self, module_id: str) -> str | None:
+        """Return the domain name for a module, or ``None`` if unmapped."""
+        # Exact match first
+        if module_id in self._module_to_domain:
+            return self._module_to_domain[module_id]
+        # Prefix match (e.g. ``com.example.orders`` matches ``com.example.orders.service``)
+        for mod_prefix, domain in self._module_to_domain.items():
+            if module_id.startswith(mod_prefix + ".") or module_id.startswith(mod_prefix + "/"):
+                return domain
+        return None
+
+    def roll_up(self, store: GraphStore) -> GraphStore:
+        """Collapse module-level nodes into domain-level aggregates.
+
+        Parameters
+        ----------
+        store:
+            A :class:`GraphStore` — ideally already at module level
+            (i.e. output of :meth:`ArchitectView.roll_up`).
+
+        Returns
+        -------
+        GraphStore
+            A new store with one node per domain and rolled-up edges.
+        """
+        new_store = GraphStore()
+
+        # --- 1. Build domain nodes ------------------------------------
+        domain_modules: dict[str, list[str]] = defaultdict(list)
+
+        for node in store.all_nodes():
+            domain = self._resolve_domain(node.id)
+            if domain is None:
+                # Keep unmapped nodes as-is
+                new_store.add_node(node)
+                continue
+            domain_modules[domain].append(node.id)
+
+        for domain_name, mod_ids in domain_modules.items():
+            props: dict[str, object] = {
+                "module_count": len(mod_ids),
+                "modules": mod_ids,
+            }
+            new_store.add_node(
+                GraphNode(
+                    id=f"domain:{domain_name}",
+                    kind=NodeKind.MODULE,
+                    label=domain_name,
+                    properties=props,
+                )
+            )
+
+        # --- 2. Roll up edges -----------------------------------------
+        edge_weights: dict[tuple[str, str, EdgeKind], int] = defaultdict(int)
+
+        for edge in store.all_edges():
+            src_domain = self._resolve_domain(edge.source)
+            tgt_domain = self._resolve_domain(edge.target)
+
+            src_id = f"domain:{src_domain}" if src_domain else edge.source
+            tgt_id = f"domain:{tgt_domain}" if tgt_domain else edge.target
+
+            if src_id == tgt_id:
+                continue
+
+            edge_weights[(src_id, tgt_id, edge.kind)] += 1
+
+        for (src, tgt, kind), weight in edge_weights.items():
+            props = {"weight": weight}
+            new_store.add_edge(
+                GraphEdge(
+                    source=src,
+                    target=tgt,
+                    kind=kind,
+                    label=f"{kind.value} (x{weight})" if weight > 1 else kind.value,
+                    properties=props,
+                )
+            )
+
+        return new_store

osscodeiq/models/__init__.py

@@ -0,0 +1,17 @@
+from osscodeiq.models.graph import (
+    CodeGraph,
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+__all__ = [
+    "CodeGraph",
+    "EdgeKind",
+    "GraphEdge",
+    "GraphNode",
+    "NodeKind",
+    "SourceLocation",
+]

osscodeiq/models/graph.py

@@ -0,0 +1,116 @@
+"""Core graph data models for OSSCodeIQ."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class NodeKind(str, Enum):
+    """Types of nodes in the OSSCodeIQ graph."""
+
+    MODULE = "module"
+    PACKAGE = "package"
+    CLASS = "class"
+    METHOD = "method"
+    ENDPOINT = "endpoint"
+    ENTITY = "entity"
+    REPOSITORY = "repository"
+    QUERY = "query"
+    MIGRATION = "migration"
+    TOPIC = "topic"
+    QUEUE = "queue"
+    EVENT = "event"
+    RMI_INTERFACE = "rmi_interface"
+    CONFIG_FILE = "config_file"
+    CONFIG_KEY = "config_key"
+    WEBSOCKET_ENDPOINT = "websocket_endpoint"
+    INTERFACE = "interface"
+    ABSTRACT_CLASS = "abstract_class"
+    ENUM = "enum"
+    ANNOTATION_TYPE = "annotation_type"
+    PROTOCOL_MESSAGE = "protocol_message"
+    CONFIG_DEFINITION = "config_definition"
+    DATABASE_CONNECTION = "database_connection"
+    AZURE_RESOURCE = "azure_resource"
+    AZURE_FUNCTION = "azure_function"
+    MESSAGE_QUEUE = "message_queue"
+    INFRA_RESOURCE = "infra_resource"
+    COMPONENT = "component"
+    GUARD = "guard"
+    MIDDLEWARE = "middleware"
+    HOOK = "hook"
+
+
+class EdgeKind(str, Enum):
+    """Types of edges (relationships) in the OSSCodeIQ graph."""
+
+    DEPENDS_ON = "depends_on"
+    IMPORTS = "imports"
+    EXTENDS = "extends"
+    IMPLEMENTS = "implements"
+    CALLS = "calls"
+    INJECTS = "injects"
+    EXPOSES = "exposes"
+    QUERIES = "queries"
+    MAPS_TO = "maps_to"
+    PRODUCES = "produces"
+    CONSUMES = "consumes"
+    PUBLISHES = "publishes"
+    LISTENS = "listens"
+    INVOKES_RMI = "invokes_rmi"
+    EXPORTS_RMI = "exports_rmi"
+    READS_CONFIG = "reads_config"
+    MIGRATES = "migrates"
+    CONTAINS = "contains"
+    DEFINES = "defines"
+    OVERRIDES = "overrides"
+    CONNECTS_TO = "connects_to"
+    TRIGGERS = "triggers"
+    PROVISIONS = "provisions"
+    SENDS_TO = "sends_to"
+    RECEIVES_FROM = "receives_from"
+    PROTECTS = "protects"
+    RENDERS = "renders"
+
+
+class SourceLocation(BaseModel):
+    """Source code location reference."""
+
+    file_path: str
+    line_start: int | None = None
+    line_end: int | None = None
+
+
+class GraphNode(BaseModel):
+    """A node in the OSSCodeIQ graph."""
+
+    id: str
+    kind: NodeKind
+    label: str
+    fqn: str | None = None
+    module: str | None = None
+    location: SourceLocation | None = None
+    annotations: list[str] = Field(default_factory=list)
+    properties: dict[str, Any] = Field(default_factory=dict)
+
+
+class GraphEdge(BaseModel):
+    """An edge (relationship) in the OSSCodeIQ graph."""
+
+    source: str
+    target: str
+    kind: EdgeKind
+    label: str | None = None
+    properties: dict[str, Any] = Field(default_factory=dict)
+
+
+class CodeGraph(BaseModel):
+    """Top-level serializable graph container."""
+
+    version: str = "1.0.0"
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    nodes: list[GraphNode] = Field(default_factory=list)
+    edges: list[GraphEdge] = Field(default_factory=list)