Query Engine

def get_node(self, node_id: str) -> Optional[Dict[str, Any]]:
    """Retrieve single node by ID."""
    return self.storage.get_node(node_id)

def downstream(self, node_id: str, max_depth: int = 10, 
               edge_types: List[str] = None) -> List[Dict[str, Any]]:
    """
    Get all transitive dependencies (what this node depends on).
    
    Args:
        node_id: Starting node ID
        max_depth: Maximum traversal depth to prevent infinite loops
        edge_types: Optional list of edge types to follow
    """
    edge_filter = ""
    if edge_types:
        edge_types_upper = [et.upper() for et in edge_types]
        edge_filter = f"WHERE type(r) IN {edge_types_upper}"
    
    query = f"""
    MATCH path = (start {{id: $node_id}})-[r*1..{max_depth}]->(dependency)
    {edge_filter}
    WITH dependency, min(length(path)) as distance
    RETURN dependency, distance
    ORDER BY distance, dependency.name
    """
    
    result = self.storage.execute_cypher(query, {'node_id': node_id})
    return [
        {
            **dict(record['dependency']),
            'distance': record['distance']
        }
        for record in result
    ]

def blast_radius(self, node_id: str, max_depth: int = 10) -> Dict[str, Any]:
    """
    Full impact analysis - upstream + downstream + affected teams.
    
    Args:
        node_id: Starting node ID
        max_depth: Maximum traversal depth
    """
    # Get the starting node
    start_node = self.get_node(node_id)
    if not start_node:
        return {'error': f'Node {node_id} not found'}
    
    # Get upstream and downstream dependencies
    upstream_nodes = self.upstream(node_id, max_depth)
    downstream_nodes = self.downstream(node_id, max_depth)
    
    # Get all affected node IDs
    affected_node_ids = {node_id}
    affected_node_ids.update(node['id'] for node in upstream_nodes)
    affected_node_ids.update(node['id'] for node in downstream_nodes)
    
    # Find teams that own any of the affected nodes
    affected_teams = set()
    for affected_id in affected_node_ids:
        query = """
        MATCH (team {type: 'team'})-[:OWNS]->(node {id: $node_id})
        RETURN team
        """
        team_result = self.storage.execute_cypher(query, {'node_id': affected_id})
        for record in team_result:
            team = dict(record['team'])
            affected_teams.add(team['name'])
    
    return {
        'center_node': start_node,
        'upstream_dependencies': upstream_nodes,
        'downstream_dependencies': downstream_nodes,
        'affected_teams': list(affected_teams),
        'total_affected_nodes': len(affected_node_ids),
        'summary': f"If {start_node['name']} fails, it could affect {len(upstream_nodes)} upstream and {len(downstream_nodes)} downstream components, impacting {len(affected_teams)} teams."
    }

def path(self, from_id: str, to_id: str, max_depth: int = 10) -> Dict[str, Any]:
    """
    Find shortest path between two nodes.
    
    Args:
        from_id: Source node ID
        to_id: Target node ID
        max_depth: Maximum path length to search
    """
    query = f"""
    MATCH path = shortestPath((start {{id: $from_id}})-[*1..{max_depth}]-(end {{id: $to_id}}))
    RETURN [node in nodes(path) | {{id: node.id, name: node.name, type: node.type}}] as nodes,
           [rel in relationships(path) | type(rel)] as relationships,
           length(path) as path_length
    """
    
    result = self.storage.execute_cypher(query, {
        'from_id': from_id,
        'to_id': to_id
    })
    
    if result:
        record = result[0]
        return {
            'nodes': record['nodes'],
            'relationships': record['relationships'],
            'path_length': record['path_length'],
            'path_description': self._format_path_description(
                record['nodes'], 
                record['relationships']
            )
        }
    
    return {
        'nodes': [],
        'relationships': [],
        'path_length': 0,
        'path_description': f"No path found between {from_id} and {to_id}"
    }

def get_owner(self, node_id: str) -> Optional[Dict[str, Any]]:
    """Find the team that owns a given node."""
    query = """
    MATCH (team {type: 'team'})-[:OWNS]->(node {id: $node_id})
    RETURN team
    """
    
    result = self.storage.execute_cypher(query, {'node_id': node_id})
    if result:
        return dict(result[0]['team'])
    return None

def get_services_using_database(self, database_name: str) -> List[Dict[str, Any]]:
    """Find all services that use a specific database."""
    query = """
    MATCH (service)-[:USES]->(db {name: $db_name})
    WHERE db.type IN ['database', 'cache']
    RETURN service
    ORDER BY service.name
    """
    
    result = self.storage.execute_cypher(query, {'db_name': database_name})
    return [dict(record['service']) for record in result]