Delete directory 'src'

2026-07-01 14:00:05 +00:00
parent 5068bf8e6e
commit 3eadf30f93
29 changed files with 0 additions and 1236 deletions
@@ -1 +0,0 @@
 # src package initialization
@@ -1,105 +0,0 @@
 const { Graph, Node, ReflectionNode, RewritingNode } = require('../index');
 describe('Graph with Reflection and Rewriting Nodes', () => {
  test('ReflectionNode creates reflected nodes with copied edges', () => {
    const graph = new Graph();
    const a = new Node('A');
    const b = new Node('B');
    const c = new Node('C');
    graph.addNode(a);
    graph.addNode(b);
    graph.addNode(c);
    graph.addEdge('A', 'B');
    graph.addEdge('B', 'C');
    const r = new ReflectionNode('R');
    graph.addNode(r);
    graph.addEdge('R', 'B');
    r.reflect(graph);
    const bRef = graph.getNode('B_ref');
    expect(bRef).toBeDefined();
    expect(bRef.type).toBe('generic');
    const edges = graph.edges.get('B_ref');
    expect(edges).toContain('C');
  });
  test('RewritingNode replaces target node with new node', () => {
    const graph = new Graph();
    const a = new Node('A');
    const b = new Node('B');
    const c = new Node('C');
    graph.addNode(a);
    graph.addNode(b);
    graph.addNode(c);
    graph.addEdge('A', 'B');
    graph.addEdge('B', 'C');
    const w = new RewritingNode('W');
    graph.addNode(w);
    graph.addEdge('W', 'C');
    const d = new Node('D');
    w.rewrite(graph, 'C', d);
    expect(graph.getNode('C')).toBeUndefined();
    expect(graph.getNode('D')).toBeDefined();
    const edges = graph.edges.get('B');
    expect(edges).toContain('D');
  });
  test('Circular references are handled without infinite recursion', () => {
    const graph = new Graph();
    const x = new Node('X');
    const y = new Node('Y');
    graph.addNode(x);
    graph.addNode(y);
    graph.addEdge('X', 'Y');
    graph.addEdge('Y', 'X');
    const r = new ReflectionNode('R');
    graph.addNode(r);
    graph.addEdge('R', 'X');
    expect(() => r.reflect(graph)).not.toThrow();
    const xRef = graph.getNode('X_ref');
    expect(xRef).toBeDefined();
    const edges = graph.edges.get('X_ref');
    expect(edges).toContain('Y');
  });
  test('Graph traversal works correctly after reflection and rewriting', () => {
    const graph = new Graph();
    const a = new Node('A');
    const b = new Node('B');
    const c = new Node('C');
    graph.addNode(a);
    graph.addNode(b);
    graph.addNode(c);
    graph.addEdge('A', 'B');
    graph.addEdge('B', 'C');
    const r = new ReflectionNode('R');
    graph.addNode(r);
    graph.addEdge('R', 'B');
    r.reflect(graph);
    const w = new RewritingNode('W');
    graph.addNode(w);
    graph.addEdge('W', 'C');
    const d = new Node('D');
    w.rewrite(graph, 'C', d);
    const traversal = graph.traverse('A');
    // Should visit A, B, D, and B_ref (which points to D)
    expect(traversal).toContain('A');
    expect(traversal).toContain('B');
    expect(traversal).toContain('D');
    expect(traversal).toContain('B_ref');
    // Ensure no duplicate nodes in traversal
    const unique = new Set(traversal);
    expect(unique.size).toBe(traversal.length);
  });
 });
@@ -1,17 +0,0 @@
 import { OpenAI } from 'langchain-openai';
 /**
 * Generates a response from the LLM for a given prompt.
 *
 * @param {string} prompt - The input prompt to send to the LLM.
 * @returns {Promise<string>} The LLM's response text.
 */
 export async function getResponse(prompt) {
  const model = new OpenAI({
    temperature: 0.7,
    modelName: 'gpt-3.5-turbo'
  });
  const response = await model.invoke(prompt);
  return response;
 }
@@ -1,82 +0,0 @@
 import os
 from typing import Dict, List
 from langgraph.graph import StateGraph, END
 from langchain_openai import ChatOpenAI
 from langchain_core.messages import HumanMessage, AIMessage, BaseMessage
 # Define the state type for the graph
 class GraphState:
    messages: List[BaseMessage]
 def llm_node(state: Dict[str, List[BaseMessage]]) -> Dict[str, List[BaseMessage]]:
    """
    Node that sends the current conversation to the LLM and appends the response.
    """
    # Retrieve the current messages
    messages = state["messages"]
    # Initialize the LLM (OpenAI)
    llm = ChatOpenAI(
        api_key=os.getenv("OPENAI_API_KEY"),
        model="gpt-4o-mini",  # You can change the model as needed
    )
    # Call the LLM with the conversation history
    response: AIMessage = llm.invoke(messages)
    # Append the LLM response to the conversation
    new_messages = messages + [response]
    return {"messages": new_messages}
 def create_agent() -> StateGraph:
    """
    Creates a simple LangGraph agent that uses the LLM node.
    """
    # Initialize the graph
    graph = StateGraph(GraphState)
    # Add the LLM node
    graph.add_node("llm", llm_node)
    # Set the entry point and end condition
    graph.set_entry_point("llm")
    graph.add_edge("llm", END)
    return graph
 def run_agent(prompt: str) -> str:
    """
    Runs the agent with the given prompt and returns the LLM's final response.
    """
    # Create the graph
    graph = create_agent()
    # Build the initial state
    initial_state = {"messages": [HumanMessage(content=prompt)]}
    # Run the graph
    final_state = graph.invoke(initial_state)
    # Extract the last AI message
    ai_messages = [msg for msg in final_state["messages"] if isinstance(msg, AIMessage)]
    if not ai_messages:
        return "No response from LLM."
    return ai_messages[-1].content
 if __name__ == "__main__":
    # Simple CLI usage
    import argparse
    parser = argparse.ArgumentParser(description="Run the LangGraph agent with OpenAI LLM.")
    parser.add_argument("prompt", type=str, help="The prompt to send to the agent.")
    args = parser.parse_args()
    response = run_agent(args.prompt)
    print("Agent response:")
    print(response)
@@ -1,47 +0,0 @@
 /**
 * Simple graph implementation that executes nodes in a defined sequence.
 */
 class Graph {
  constructor() {
    this.nodes = {};
  }
  /**
   * Adds a node to the graph.
   * @param {string} name - Unique name of the node.
   * @param {function} fn - Function that processes input and returns output.
   */
  addNode(name, fn) {
    if (typeof fn !== 'function') {
      throw new Error('Node must be a function.');
    }
    this.nodes[name] = fn;
  }
  /**
   * Executes a sequence of nodes with the given input.
   * @param {Array<string>} nodeSequence - Ordered list of node names to execute.
   * @param {any} input - Initial input for the first node.
   * @returns {Promise<any>} - Final output after all nodes have processed the data.
   */
  async run(nodeSequence, input) {
    if (!Array.isArray(nodeSequence)) {
      throw new Error('nodeSequence must be an array of node names.');
    }
    let data = input;
    for (const name of nodeSequence) {
      const fn = this.nodes[name];
      if (!fn) {
        throw new Error(`Node "${name}" not found in the graph.`);
      }
      try {
        data = await fn(data);
      } catch (err) {
        throw new Error(`Error in node "${name}": ${err.message}`);
      }
    }
    return data;
  }
 }
 module.exports = Graph;
@@ -1,73 +0,0 @@
 """
 Graph implementation that connects nodes and executes them in sequence.
 """
 from typing import Dict, List
 from .nodes import BaseNode, InputNode, OutputNode, ReflectionNode, RewritingNode
 class Graph:
    """
    Simple directed acyclic graph for node execution.
    """
    def __init__(self):
        self.nodes: Dict[str, BaseNode] = {}
        self.edges: Dict[str, List[str]] = {}
    def add_node(self, node: BaseNode):
        self.nodes[node.node_id] = node
        self.edges.setdefault(node.node_id, [])
    def add_edge(self, from_node_id: str, to_node_id: str):
        if from_node_id not in self.nodes or to_node_id not in self.nodes:
            raise ValueError("Both nodes must be added before creating an edge.")
        self.edges[from_node_id].append(to_node_id)
    def _find_start_node(self) -> str:
        # Node with no incoming edges
        all_targets = {t for targets in self.edges.values() for t in targets}
        for node_id in self.nodes:
            if node_id not in all_targets:
                return node_id
        raise RuntimeError("No start node found (graph may contain a cycle).")
    def run(self, input_data: str) -> Any:
        """
        Execute the graph starting from the start node.
        """
        current_node_id = self._find_start_node()
        data = input_data
        while True:
            node = self.nodes[current_node_id]
            data = node.process(data)
            successors = self.edges.get(current_node_id, [])
            if not successors:
                # End of graph
                return data
            # For simplicity, take the first successor
            current_node_id = successors[0]
 def build_example_graph() -> Graph:
    """
    Builds an example graph with an InputNode, ReflectionNode, RewritingNode, and OutputNode.
    """
    graph = Graph()
    input_node = InputNode("input")
    reflection_node = ReflectionNode("reflection")
    rewriting_node = RewritingNode("rewriting", style="concise")
    output_node = OutputNode("output")
    graph.add_node(input_node)
    graph.add_node(reflection_node)
    graph.add_node(rewriting_node)
    graph.add_node(output_node)
    graph.add_edge("input", "reflection")
    graph.add_edge("reflection", "rewriting")
    graph.add_edge("rewriting", "output")
    return graph
@@ -1,82 +0,0 @@
 import { BaseNode } from './nodes/baseNode';
 import { ReflectionNode } from './nodes/reflectionNode';
 import { RewriteNode, RewriteFunction } from './nodes/rewriteNode';
 export type Edge = {
  from: string;
  out: string;
  to: string;
  in: string;
 };
 export class Graph {
  private nodes: Map<string, BaseNode>;
  private edges: Edge[];
  private nodeCounter: number;
  constructor() {
    this.nodes = new Map();
    this.edges = [];
    this.nodeCounter = 0;
  }
  private generateId(): string {
    return `node_${this.nodeCounter++}`;
  }
  /**
   * Creates a node of the specified type.
   * @param type 'reflection' | 'rewrite'
   * @param options For rewrite nodes, provide { func: (value) => any }
   */
  createNode(type: 'reflection' | 'rewrite', options?: any): BaseNode {
    const id = this.generateId();
    let node: BaseNode;
    if (type === 'reflection') {
      node = new ReflectionNode(id);
    } else if (type === 'rewrite') {
      if (!options || typeof options.func !== 'function') {
        throw new Error('Rewrite node requires a func option');
      }
      node = new RewriteNode(id, options.func);
    } else {
      throw new Error(`Unknown node type: ${type}`);
    }
    this.nodes.set(id, node);
    return node;
  }
  addNode(node: BaseNode): void {
    if (this.nodes.has(node.id)) {
      throw new Error(`Node with id ${node.id} already exists`);
    }
    this.nodes.set(node.id, node);
  }
  addEdge(from: string, out: string, to: string, inKey: string): void {
    if (!this.nodes.has(from) || !this.nodes.has(to)) {
      throw new Error('Both nodes must exist to add an edge');
    }
    this.edges.push({ from, out, to, in: inKey });
  }
  /**
   * Executes the graph in a simple order: nodes are processed in the order they were added.
   * After each node processes, its outputs are propagated to connected nodes.
   */
  run(): void {
    for (const node of this.nodes.values()) {
      node.process();
      for (const edge of this.edges.filter(e => e.from === node.id)) {
        const target = this.nodes.get(edge.to);
        if (!target) continue;
        const value = node.outputs.get(edge.out);
        target.inputs.set(edge.in, value);
      }
    }
  }
  getNode(id: string): BaseNode | undefined {
    return this.nodes.get(id);
  }
 }
@@ -1,80 +0,0 @@
 class Graph {
  constructor() {
    this.nodes = new Map(); // nodeId -> nodeData
    this.edges = new Map(); // nodeId -> Set of neighbor nodeIds
    this.edgeData = new Map(); // key `${from}->${to}` -> data
  }
  addNode(id, data = {}) {
    if (this.nodes.has(id)) {
      throw new Error(`Node with id ${id} already exists`);
    }
    this.nodes.set(id, data);
    this.edges.set(id, new Set());
  }
  addEdge(from, to, data = {}) {
    if (!this.nodes.has(from) || !this.nodes.has(to)) {
      throw new Error(`Both nodes must exist to add an edge`);
    }
    this.edges.get(from).add(to);
    const key = `${from}->${to}`;
    this.edgeData.set(key, data);
  }
  getNeighbors(id) {
    if (!this.nodes.has(id)) {
      throw new Error(`Node with id ${id} does not exist`);
    }
    return Array.from(this.edges.get(id));
  }
  getNode(id) {
    return this.nodes.get(id);
  }
  getAllNodes() {
    return Array.from(this.nodes.keys());
  }
  getAllEdges() {
    const edges = [];
    for (const [from, neighbors] of this.edges.entries()) {
      for (const to of neighbors) {
        const key = `${from}->${to}`;
        edges.push({ from, to, data: this.edgeData.get(key) });
      }
    }
    return edges;
  }
  getEdgeData(from, to) {
    const key = `${from}->${to}`;
    return this.edgeData.get(key);
  }
  // Reflection methods
  getProperties() {
    return Object.getOwnPropertyNames(this);
  }
  getMethods() {
    const proto = Object.getPrototypeOf(this);
    return Object.getOwnPropertyNames(proto).filter(
      (name) => typeof this[name] === 'function' && name !== 'constructor'
    );
  }
  // Introspection utilities
  getNodeProperties(id) {
    const node = this.nodes.get(id);
    return node ? Object.keys(node) : null;
  }
  getEdgeProperties(from, to) {
    const data = this.getEdgeData(from, to);
    return data ? Object.keys(data) : null;
  }
 }
 module.exports = Graph;
@@ -1,138 +0,0 @@
 """
 Graph data structure with reflection and introspection capabilities.
 This Python implementation mirrors the JavaScript version found in
 `src/index.js`.  It provides:
 * Node and edge management (add, retrieve, list)
 * Directed edges with optional data
 * Reflection utilities (`get_properties`, `get_methods`)
 * Introspection utilities (`get_node_properties`, `get_edge_properties`)
 The API is intentionally similar to the JS version so that tests written in
 JavaScript can be easily ported to Python if needed.
 """
 from __future__ import annotations
 from typing import Any, Dict, Iterable, List, Set, Tuple, Union
 class Graph:
    """
    Directed graph with optional data on nodes and edges.
    """
    def __init__(self) -> None:
        # node_id -> node_data (dict)
        self.nodes: Dict[Any, Dict[str, Any]] = {}
        # node_id -> set of neighbor node_ids
        self.edges: Dict[Any, Set[Any]] = {}
        # (from, to) -> edge_data (dict)
        self.edge_data: Dict[Tuple[Any, Any], Dict[str, Any]] = {}
    # ------------------------------------------------------------------
    # Core graph operations
    # ------------------------------------------------------------------
    def add_node(self, node_id: Any, data: Dict[str, Any] | None = None) -> None:
        """Add a node with optional data.
        Raises:
            ValueError: If the node already exists.
        """
        if node_id in self.nodes:
            raise ValueError(f"Node with id {node_id} already exists")
        self.nodes[node_id] = data or {}
        self.edges[node_id] = set()
    def add_edge(
        self,
        from_id: Any,
        to_id: Any,
        data: Dict[str, Any] | None = None,
    ) -> None:
        """Add a directed edge from `from_id` to `to_id` with optional data.
        Raises:
            ValueError: If either node does not exist.
        """
        if from_id not in self.nodes or to_id not in self.nodes:
            raise ValueError("Both nodes must exist to add an edge")
        self.edges[from_id].add(to_id)
        self.edge_data[(from_id, to_id)] = data or {}
    def get_neighbors(self, node_id: Any) -> List[Any]:
        """Return a list of neighbor node ids for the given node."""
        if node_id not in self.nodes:
            raise ValueError(f"Node with id {node_id} does not exist")
        return list(self.edges[node_id])
    def get_node(self, node_id: Any) -> Dict[str, Any] | None:
        """Return the data dictionary for a node, or None if it doesn't exist."""
        return self.nodes.get(node_id)
    def get_all_nodes(self) -> List[Any]:
        """Return a list of all node ids."""
        return list(self.nodes.keys())
    def get_all_edges(self) -> List[Dict[str, Any]]:
        """Return a list of all edges as dictionaries."""
        edges: List[Dict[str, Any]] = []
        for from_id, neighbors in self.edges.items():
            for to_id in neighbors:
                edges.append(
                    {
                        "from": from_id,
                        "to": to_id,
                        "data": self.edge_data.get((from_id, to_id)),
                    }
                )
        return edges
    def get_edge_data(self, from_id: Any, to_id: Any) -> Dict[str, Any] | None:
        """Return the data dictionary for an edge, or None if it doesn't exist."""
        return self.edge_data.get((from_id, to_id))
    # ------------------------------------------------------------------
    # Reflection utilities
    # ------------------------------------------------------------------
    def get_properties(self) -> List[str]:
        """Return the names of own instance attributes."""
        return list(self.__dict__.keys())
    def get_methods(self) -> List[str]:
        """Return the names of public methods defined on the class."""
        methods = [
            name
            for name, value in vars(self.__class__).items()
            if callable(value) and not name.startswith("_")
        ]
        return methods
    # ------------------------------------------------------------------
    # Introspection utilities
    # ------------------------------------------------------------------
    def get_node_properties(self, node_id: Any) -> List[str] | None:
        """Return the keys of the node's data dictionary."""
        node = self.nodes.get(node_id)
        return list(node.keys()) if node is not None else None
    def get_edge_properties(self, from_id: Any, to_id: Any) -> List[str] | None:
        """Return the keys of the edge's data dictionary."""
        edge = self.edge_data.get((from_id, to_id))
        return list(edge.keys()) if edge is not None else None
 # If this module is run directly, demonstrate basic usage.
 if __name__ == "__main__":
    g = Graph()
    g.add_node("a", {"value": 1})
    g.add_node("b", {"value": 2})
    g.add_edge("a", "b", {"weight": 5})
    print("Nodes:", g.get_all_nodes())
    print("Edges:", g.get_all_edges())
    print("Neighbors of a:", g.get_neighbors("a"))
    print("Properties:", g.get_properties())
    print("Methods:", g.get_methods())
    print("Node 'a' properties:", g.get_node_properties("a"))
    print("Edge a->b properties:", g.get_edge_properties("a", "b"))
@@ -1,94 +0,0 @@
 const Graph = require('./index');
 describe('Graph', () => {
  let graph;
  beforeEach(() => {
    graph = new Graph();
  });
  test('should add nodes and retrieve them', () => {
    graph.addNode('a', { value: 1 });
    graph.addNode('b', { value: 2 });
    expect(graph.getNode('a')).toEqual({ value: 1 });
    expect(graph.getNode('b')).toEqual({ value: 2 });
    expect(graph.getAllNodes()).toEqual(expect.arrayContaining(['a', 'b']));
  });
  test('should throw error when adding duplicate node', () => {
    graph.addNode('a');
    expect(() => graph.addNode('a')).toThrow(/already exists/);
  });
  test('should add edges and retrieve neighbors', () => {
    graph.addNode('a');
    graph.addNode('b');
    graph.addNode('c');
    graph.addEdge('a', 'b', { weight: 5 });
    graph.addEdge('a', 'c', { weight: 3 });
    expect(graph.getNeighbors('a')).toEqual(expect.arrayContaining(['b', 'c']));
    expect(graph.getNeighbors('b')).toEqual([]);
  });
  test('should throw error when adding edge with non-existent node', () => {
    graph.addNode('a');
    expect(() => graph.addEdge('a', 'x')).toThrow(/Both nodes must exist/);
  });
  test('should retrieve edge data', () => {
    graph.addNode('a');
    graph.addNode('b');
    graph.addEdge('a', 'b', { weight: 10 });
    expect(graph.getEdgeData('a', 'b')).toEqual({ weight: 10 });
  });
  test('should retrieve all edges', () => {
    graph.addNode('a');
    graph.addNode('b');
    graph.addNode('c');
    graph.addEdge('a', 'b', { weight: 1 });
    graph.addEdge('b', 'c', { weight: 2 });
    const edges = graph.getAllEdges();
    expect(edges).toEqual(
      expect.arrayContaining([
        { from: 'a', to: 'b', data: { weight: 1 } },
        { from: 'b', to: 'c', data: { weight: 2 } },
      ])
    );
  });
  test('reflection: getProperties should return own properties', () => {
    const props = graph.getProperties();
    expect(props).toEqual(expect.arrayContaining(['nodes', 'edges', 'edgeData']));
  });
  test('reflection: getMethods should return method names', () => {
    const methods = graph.getMethods();
    const expected = [
      'addNode',
      'addEdge',
      'getNeighbors',
      'getNode',
      'getAllNodes',
      'getAllEdges',
      'getEdgeData',
      'getProperties',
      'getMethods',
      'getNodeProperties',
      'getEdgeProperties',
    ];
    expect(methods).toEqual(expect.arrayContaining(expected));
  });
  test('introspection: getNodeProperties should return node data keys', () => {
    graph.addNode('a', { x: 1, y: 2 });
    expect(graph.getNodeProperties('a')).toEqual(expect.arrayContaining(['x', 'y']));
  });
  test('introspection: getEdgeProperties should return edge data keys', () => {
    graph.addNode('a');
    graph.addNode('b');
    graph.addEdge('a', 'b', { weight: 5, label: 'ab' });
    expect(graph.getEdgeProperties('a', 'b')).toEqual(expect.arrayContaining(['weight', 'label']));
  });
 });
@@ -1,4 +0,0 @@
 export { Graph } from './graph';
 export { BaseNode } from './nodes/baseNode';
 export { ReflectionNode } from './nodes/reflectionNode';
 export { RewriteNode, RewriteFunction } from './nodes/rewriteNode';
@@ -1,41 +0,0 @@
 import { StateGraph } from 'langgraph';
 export type State = {
  input: string;
  output?: string;
 };
 const startFn = (state: State) => {
  // The start node simply passes the initial state through.
  return state;
 };
 const reflection = (state: State) => {
  console.log('Reflection node:', state);
  return state;
 };
 const rewriting = (state: State) => {
  const newState = { ...state, output: state.input.toUpperCase() };
  console.log('Rewriting node:', newState);
  return newState;
 };
 const end = (state: State) => {
  console.log('End node:', state);
  return state;
 };
 export const graph = new StateGraph<State>();
 graph.addNode('start', startFn);
 graph.addNode('reflection', reflection);
 graph.addNode('rewriting', rewriting);
 graph.addNode('end', end);
 graph.setEntryPoint('start');
 graph.addEdge('start', 'reflection');
 graph.addEdge('reflection', 'rewriting');
 graph.addEdge('rewriting', 'end');
 export const app = graph.compile();
@@ -1,33 +0,0 @@
 """
 LLM integration module for LangChain with support for OpenAI and Ollama.
 Provides a reusable LLM client based on environment configuration.
 """
 import os
 from typing import Union
 from langchain.llms import OpenAI, Ollama
 from langchain.chat_models import ChatOpenAI, ChatOllama
 # Environment variable to select provider: "openai" or "ollama"
 LLM_PROVIDER = os.getenv("LLM_PROVIDER", "openai").lower()
 def get_llm() -> Union[OpenAI, Ollama, ChatOpenAI, ChatOllama]:
    """
    Returns an LLM instance based on the configured provider.
    For OpenAI, uses the default OpenAI LLM (text-davinci-003 or gpt-3.5-turbo).
    For Ollama, uses the default Ollama LLM (e.g., llama2).
    Raises:
        ValueError: If an unsupported provider is specified.
    """
    if LLM_PROVIDER == "openai":
        # Use ChatOpenAI for GPT-3.5-turbo by default
        return ChatOpenAI(temperature=0.7)
    elif LLM_PROVIDER == "ollama":
        # Use ChatOllama for local models
        return ChatOllama(model="llama2", temperature=0.7)
    else:
        raise ValueError(f"Unsupported LLM provider: {LLM_PROVIDER}")
@@ -1,38 +0,0 @@
 """
 Entry point for running the graph with user-provided text.
 """
 import argparse
 import sys
 from .graph import build_example_graph
 def main():
    parser = argparse.ArgumentParser(description="Run the reflection and rewriting graph.")
    parser.add_argument(
        "text",
        nargs="?",
        help="Input text to process. If omitted, reads from stdin.",
    )
    args = parser.parse_args()
    if args.text:
        input_text = args.text
    else:
        input_text = sys.stdin.read()
    graph = build_example_graph()
    result = graph.run(input_text)
    # The final node returns a dict with 'rewritten' key
    if isinstance(result, dict) and "rewritten" in result:
        print("Rewritten Text:\n")
        print(result["rewritten"])
    else:
        print("Result:")
        print(result)
 if __name__ == "__main__":
    main()
@@ -1,42 +0,0 @@
 export class Node {
  /**
   * @param {string} id - Unique identifier for the node
   * @param {object} [data={}] - Optional payload
   */
  constructor(id, data = {}) {
    if (!id) {
      throw new Error('Node must have an id');
    }
    this.id = id;
    this.type = 'generic';
    this.data = data;
  }
 }
 export class ReflectionNode extends Node {
  constructor(id, data = {}) {
    super(id, data);
    this.type = 'reflection';
  }
  /**
   * Returns a string representation of the node for debugging.
   */
  toString() {
    return `ReflectionNode(${this.id})`;
  }
 }
 export class RewritingNode extends Node {
  constructor(id, data = {}) {
    super(id, data);
    this.type = 'rewriting';
  }
  /**
   * Returns a string representation of the node for debugging.
   */
  toString() {
    return `RewritingNode(${this.id})`;
  }
 }
@@ -1,83 +0,0 @@
 """
 Node definitions for the graph.
 Includes base Node, ReflectionNode, RewritingNode, InputNode, and OutputNode.
 """
 from abc import ABC, abstractmethod
 from typing import Any, Dict
 from .llm_integration import get_llm
 class BaseNode(ABC):
    """
    Abstract base class for all nodes in the graph.
    Each node must implement the `process` method.
    """
    def __init__(self, node_id: str):
        self.node_id = node_id
    @abstractmethod
    def process(self, input_data: Any) -> Any:
        """
        Process the input data and return the output.
        """
        pass
 class InputNode(BaseNode):
    """
    Node that simply passes through the input data.
    """
    def process(self, input_data: Any) -> Any:
        return input_data
 class OutputNode(BaseNode):
    """
    Node that collects the final output.
    """
    def process(self, input_data: Any) -> Any:
        return input_data
 class ReflectionNode(BaseNode):
    """
    Node that generates reflective insights from the input text using an LLM.
    """
    def __init__(self, node_id: str, prompt_template: str = None):
        super().__init__(node_id)
        self.prompt_template = (
            prompt_template
            or "Please reflect on the following text:\n\n{input_text}\n\nReflection:"
        )
        self.llm = get_llm()
    def process(self, input_data: str) -> Dict[str, str]:
        prompt = self.prompt_template.format(input_text=input_data)
        reflection = self.llm(prompt)
        return {"reflection": reflection.strip()}
 class RewritingNode(BaseNode):
    """
    Node that rewrites the input text according to a specified style or instruction.
    """
    def __init__(self, node_id: str, style: str = "formal"):
        super().__init__(node_id)
        self.style = style
        self.llm = get_llm()
    def process(self, input_data: Dict[str, str]) -> Dict[str, str]:
        # Expecting input_data to contain 'reflection' key
        reflection = input_data.get("reflection", "")
        prompt = (
            f"Rewrite the following reflection in a {self.style} style:\n\n{reflection}\n\nRewritten:"
        )
        rewritten = self.llm(prompt)
        return {"rewritten": rewritten.strip()}
@@ -1,12 +0,0 @@
 class BaseNode {
  constructor(name, graph) {
    this.name = name;
    this.graph = graph;
  }
  evaluate(input) {
    throw new Error('evaluate() must be implemented by subclass');
  }
 }
 module.exports = BaseNode;
@@ -1,15 +0,0 @@
 export abstract class BaseNode {
  id: string;
  type: string;
  inputs: Map<string, any>;
  outputs: Map<string, any>;
  constructor(id: string, type: string) {
    this.id = id;
    this.type = type;
    this.inputs = new Map();
    this.outputs = new Map();
  }
  abstract process(): void;
 }
@@ -1,35 +0,0 @@
 const { OpenAI } = require('langchain-openai');
 const { ChatPromptTemplate, HumanMessagePromptTemplate } = require('langchain-core/prompts');
 const { LLMChain } = require('langchain-core/chains');
 // Initialize the LLM (OpenAI) with a moderate temperature for reflective responses
 const llm = new OpenAI({ temperature: 0.7 });
 // Prompt template for reflection
 const prompt = ChatPromptTemplate.fromPromptMessages([
  HumanMessagePromptTemplate.fromTemplate(
    "Please reflect on the following message:\n\n{input}"
  ),
 ]);
 // Chain that combines the prompt and the LLM
 const chain = new LLMChain({ llm, prompt });
 /**
 * Reflects on the provided input using an LLM.
 * @param {string} input - The message to reflect upon.
 * @returns {Promise<string>} - The reflective output from the LLM.
 */
 async function reflect(input) {
  if (typeof input !== 'string') {
    throw new Error('Reflect node expects a string input.');
  }
  try {
    const result = await chain.invoke({ input });
    return result.output;
  } catch (err) {
    throw new Error(`Reflect node error: ${err.message}`);
  }
 }
 module.exports = { reflect };
@@ -1,40 +0,0 @@
 """
 Reflect node for LangGraph.
 This node takes the user input from the state and produces a reflection
 message that acknowledges the input. The output is a dictionary containing
 the key 'reflection'.
 """
 from langgraph.graph import node
 from typing import Dict, Any
 class ReflectNode:
    """
    A LangGraph node that performs reflection on the input text.
    """
    @node
    def run(self, state: Dict[str, Any]) -> Dict[str, str]:
        """
        Generate a reflection message based on the input.
        Parameters
        ----------
        state : dict
            The current state of the graph. Expected to contain an 'input'
            key with the user-provided text.
        Returns
        -------
        dict
            A dictionary with a single key 'reflection' containing the
            reflection message.
        """
        input_text = state.get("input", "")
        reflection = (
            f"I see that you said: '{input_text}'. "
            "Let's reflect on that."
        )
        return {"reflection": reflection}
@@ -1,19 +0,0 @@
 export default class ReflectionNode {
  /**
   * Creates a new ReflectionNode.
   * @param {string} id - Unique identifier for the node.
   */
  constructor(id) {
    this.id = id;
    this.type = 'reflection';
  }
  /**
   * Processes the input and returns it unchanged.
   * @param {*} input - The input value from the preceding node(s).
   * @returns {*} The same input value.
   */
  process(input) {
    return input;
  }
 }
@@ -1,14 +0,0 @@
 import { BaseNode } from './baseNode';
 export class ReflectionNode extends BaseNode {
  constructor(id: string) {
    super(id, 'reflection');
  }
  process(): void {
    // Copy all inputs to outputs with the same keys
    this.inputs.forEach((value, key) => {
      this.outputs.set(key, value);
    });
  }
 }
@@ -1,35 +0,0 @@
 const { OpenAI } = require('langchain-openai');
 const { ChatPromptTemplate, HumanMessagePromptTemplate } = require('langchain-core/prompts');
 const { LLMChain } = require('langchain-core/chains');
 // Initialize the LLM (OpenAI) with a moderate temperature for rewriting
 const llm = new OpenAI({ temperature: 0.7 });
 // Prompt template for rewriting
 const prompt = ChatPromptTemplate.fromPromptMessages([
  HumanMessagePromptTemplate.fromTemplate(
    "Rewrite the following message in a more concise and formal style:\n\n{input}"
  ),
 ]);
 // Chain that combines the prompt and the LLM
 const chain = new LLMChain({ llm, prompt });
 /**
 * Rewrites the provided input using an LLM.
 * @param {string} input - The message to rewrite.
 * @returns {Promise<string>} - The rewritten output from the LLM.
 */
 async function rewrite(input) {
  if (typeof input !== 'string') {
    throw new Error('Rewrite node expects a string input.');
  }
  try {
    const result = await chain.invoke({ input });
    return result.output;
  } catch (err) {
    throw new Error(`Rewrite node error: ${err.message}`);
  }
 }
 module.exports = { rewrite };
@@ -1,38 +0,0 @@
 """
 Rewrite node for LangGraph.
 This node takes the reflection produced by the ReflectNode and rewrites
 it to a more formal style. The output is a dictionary containing
 the key 'rewritten'.
 """
 from langgraph.graph import node
 from typing import Dict, Any
 class RewriteNode:
    """
    A LangGraph node that rewrites the reflection message.
    """
    @node
    def run(self, state: Dict[str, Any]) -> Dict[str, str]:
        """
        Rewrite the reflection message.
        Parameters
        ----------
        state : dict
            The current state of the graph. Expected to contain a 'reflection'
            key with the message produced by the ReflectNode.
        Returns
        -------
        dict
            A dictionary with a single key 'rewritten' containing the
            rewritten message.
        """
        reflection = state.get("reflection", "")
        # Simple rewrite: replace "I see" with "I notice"
        rewritten = reflection.replace("I see", "I notice")
        return {"rewritten": rewritten}
@@ -1,21 +0,0 @@
 export default class RewriteNode {
  /**
   * Creates a new RewriteNode.
   * @param {string} id - Unique identifier for the node.
   * @param {function} transform - Function that transforms the input.
   */
  constructor(id, transform) {
    this.id = id;
    this.type = 'rewrite';
    this.transform = transform;
  }
  /**
   * Processes the input using the provided transform function.
   * @param {*} input - The input value from the preceding node(s).
   * @returns {*} The transformed output.
   */
  process(input) {
    return this.transform(input);
  }
 }
@@ -1,19 +0,0 @@
 import { BaseNode } from './baseNode';
 export type RewriteFunction = (value: any) => any;
 export class RewriteNode extends BaseNode {
  private func: RewriteFunction;
  constructor(id: string, func: RewriteFunction) {
    super(id, 'rewrite');
    this.func = func;
  }
  process(): void {
    this.inputs.forEach((value, key) => {
      const newValue = this.func(value);
      this.outputs.set(key, newValue);
    });
  }
 }
@@ -1,3 +0,0 @@
 // This file has been removed from the project as it contained unrelated JavaScript code.
 // It is intentionally left empty to satisfy the requirement that no unrelated JavaScript
 // code remains in the repository.
@@ -1,3 +0,0 @@
 // Utility functions can be added here if needed in the future.
 // Currently, no utilities are required for the core graph functionality.
 module.exports = {};
@@ -1,22 +0,0 @@
 """
 Utility functions for the LangGraph project.
 """
 from langchain_openai import ChatOpenAI
 from typing import Dict, Any
 def get_llm() -> ChatOpenAI:
    """
    Returns a configured OpenAI LLM instance.
    """
    # The API key should be set in the environment variable OPENAI_API_KEY
    return ChatOpenAI(
        temperature=0.7,
        model_name="gpt-3.5-turbo",
    )
 def format_state(state: Dict[str, Any]) -> str:
    """
    Formats the state dictionary into a string for display.
    """
    return "\n".join(f"{k}: {v}" for k, v in state.items())