graph.py

import logging
import config
from langgraph.graph import StateGraph, END
from state import AgentState
from processor.processor import process
from decision.decision import is_relevant
from analysis.analyzer import analyze_node
from discovery.discoverer import discovery_node
from notifier.notifier import notify_node

logger = logging.getLogger(__name__)

def process_node(state: AgentState):
    """Wraps existing processor logic."""
    item = {
        "title": state.get("title"),
        "content": state.get("text"),
        "link": state.get("link")
    }
    processed = process(item)
    return {
        "normalized_content": processed.get("normalized_content")
    }

def decide_node(state: AgentState):
    """Wraps existing decision logic."""
    text = state.get("normalized_content") or state.get("text")
    is_rel, summary = is_relevant(text, config.KEYWORDS)
    return {
        "is_relevant": is_rel,
        "summary": summary
    }

def should_analyze(state: AgentState):
    """Conditional logic for the graph."""
    if state.get("is_relevant"):
        return "analyze"
    return END

def create_graph():
    """
    Creates and compiles the LangGraph for the monitoring agent.
    Flow: process -> decide -> (if relevant: analyze -> discover -> notify) -> END
    """
    workflow = StateGraph(AgentState)
    
    # Add Nodes
    workflow.add_node("process", process_node)
    workflow.add_node("decide", decide_node)
    workflow.add_node("analyze", analyze_node)
    workflow.add_node("discover", discovery_node)
    workflow.add_node("notify", notify_node)
    
    # Build Edges
    workflow.set_entry_point("process")
    workflow.add_edge("process", "decide")
    
    # Conditional Edge
    workflow.add_conditional_edges(
        "decide",
        should_analyze,
        {
            "analyze": "analyze",
            END: END
        }
    )
    
    workflow.add_edge("analyze", "discover")
    workflow.add_edge("discover", "notify")
    workflow.add_edge("notify", END)
    
    return workflow.compile()

# Singleton instance of the compiled graph
agent_graph = create_graph()