htmlgraph 0.9.3__py3-none-any.whl → 0.27.5__py3-none-any.whl

htmlgraph/collections/base.py

@@ -1,3 +1,9 @@
+from __future__ import annotations
+
+import logging
+
+logger = logging.getLogger(__name__)
+
 """
 Base collection class for managing nodes.
 
@@ -5,16 +11,20 @@ Provides common collection functionality for all node types
 with lazy-loading, filtering, and batch operations.
 """
 
-from __future__ import annotations
-from typing import TYPE_CHECKING, TypeVar, Generic, Any, Iterator
+
+from collections.abc import Callable, Iterator
 from contextlib import contextmanager
 from datetime import datetime
+from typing import TYPE_CHECKING, Any, Generic, Literal, TypeVar, cast
+
+from htmlgraph.exceptions import ClaimConflictError, NodeNotFoundError
 
 if TYPE_CHECKING:
-    from htmlgraph.sdk import SDK
+    from htmlgraph.graph import HtmlGraph
     from htmlgraph.models import Node
+    from htmlgraph.sdk import SDK
 
-CollectionT = TypeVar('CollectionT', bound='BaseCollection')
+CollectionT = TypeVar("CollectionT", bound="BaseCollection")
 
 
 class BaseCollection(Generic[CollectionT]):
@@ -40,8 +50,16 @@ class BaseCollection(Generic[CollectionT]):
 
     _collection_name: str = "nodes"  # Override in subclasses
     _node_type: str = "node"  # Override in subclasses
+    _builder_class: type | None = (
+        None  # Override in subclasses to enable builder pattern
+    )
 
-    def __init__(self, sdk: 'SDK', collection_name: str | None = None, node_type: str | None = None):
+    def __init__(
+        self,
+        sdk: SDK,
+        collection_name: str | None = None,
+        node_type: str | None = None,
+    ):
         """
         Initialize a collection.
 
@@ -55,26 +73,181 @@ class BaseCollection(Generic[CollectionT]):
         self._sdk = sdk
         self._collection_name = collection_name or self._collection_name
         self._node_type = node_type or self._node_type
-        self._graph = None  # Lazy-loaded
+        self._graph: HtmlGraph | None = None  # Lazy-loaded
+        self._ref_manager: Any = None  # Set by SDK during initialization
+
+    def _ensure_graph(self) -> HtmlGraph:
+        """
+        Get or initialize the graph for this collection.
 
-    def _ensure_graph(self):
-        """Lazy-load the graph for this collection."""
+        Uses SDK's shared graph instances where available to avoid creating
+        multiple graph objects for the same collection. Creates a new instance
+        for unrecognized collections.
+
+        Returns:
+            HtmlGraph instance for this collection
+
+        Note:
+            This method is lazy - the graph is only loaded on first access.
+        """
         if self._graph is None:
-            from htmlgraph.graph import HtmlGraph
-            collection_path = self._sdk._directory / self._collection_name
-            self._graph = HtmlGraph(collection_path, auto_load=True)
+            # Use SDK's shared graph instances to avoid multiple graph objects
+            if self._collection_name == "features" and hasattr(self._sdk, "_graph"):
+                self._graph = self._sdk._graph
+            elif self._collection_name == "bugs" and hasattr(self._sdk, "_bugs_graph"):
+                self._graph = self._sdk._bugs_graph
+            else:
+                # For other collections, create a new graph instance
+                from htmlgraph.graph import HtmlGraph
+
+                collection_path = self._sdk._directory / self._collection_name
+                self._graph = HtmlGraph(collection_path, auto_load=True)
+
+            # Ensure graph is loaded
+            if not self._graph._nodes:
+                self._graph.reload()
+
         return self._graph
 
+    def __getattribute__(self, name: str) -> Any:
+        """
+        Override attribute access to provide helpful error messages.
+
+        When an attribute doesn't exist, provides suggestions for common
+        mistakes and similar method names to improve discoverability.
+
+        Args:
+            name: Attribute name being accessed
+
+        Returns:
+            The requested attribute
+
+        Raises:
+            AttributeError: With helpful suggestions if attribute not found
+        """
+        try:
+            return object.__getattribute__(self, name)
+        except AttributeError as e:
+            # Get available methods
+            available = [m for m in dir(self) if not m.startswith("_")]
+
+            # Common mistakes mapping
+            common_mistakes = {
+                "mark_complete": "mark_done",
+                "complete": "Use complete(node_id) for single item or mark_done([ids]) for batch",
+                "finish": "mark_done",
+                "end": "mark_done",
+                "update_status": "edit() context manager or batch_update()",
+                "mark_as_done": "mark_done",
+                "set_done": "mark_done",
+                "complete_all": "mark_done",
+            }
+
+            suggestions = []
+            if name in common_mistakes:
+                suggestions.append(f"Did you mean: {common_mistakes[name]}")
+
+            # Find similar method names
+            similar = [
+                m
+                for m in available
+                if name.lower() in m.lower() or m.lower() in name.lower()
+            ]
+            if similar:
+                suggestions.append(f"Similar methods: {', '.join(similar[:5])}")
+
+            # Build helpful error message
+            error_msg = f"'{type(self).__name__}' has no attribute '{name}'."
+            if suggestions:
+                error_msg += "\n\n" + "\n".join(suggestions)
+            error_msg += f"\n\nAvailable methods: {', '.join(available[:15])}"
+            error_msg += "\n\nTip: Use sdk.help() to see all available operations."
+
+            raise AttributeError(error_msg) from e
+
+    def __dir__(self) -> list[str]:
+        """
+        Return attributes with most useful ones first.
+
+        Orders attributes to show commonly-used methods first in auto-complete
+        and help() output, improving discoverability for new users.
+
+        Returns:
+            List of attribute names, ordered by priority then alphabetically
+        """
+        priority = [
+            # Creation and retrieval
+            "create",
+            "get",
+            "all",
+            "where",
+            "filter",
+            # Work management
+            "start",
+            "complete",
+            "claim",
+            "release",
+            # Editing
+            "edit",
+            "update",
+            # Batch operations
+            "mark_done",
+            "assign",
+            "batch_update",
+            # Deletion
+            "delete",
+            "batch_delete",
+        ]
+        # Get all attributes
+        all_attrs = object.__dir__(self)
+        # Separate into priority, regular, and dunder attributes
+        regular = [a for a in all_attrs if not a.startswith("_") and a not in priority]
+        dunder = [a for a in all_attrs if a.startswith("_")]
+        # Return priority items first, then regular, then dunder
+        return priority + regular + dunder
+
+    def set_ref_manager(self, ref_manager: Any) -> None:
+        """
+        Set the ref manager for this collection.
+
+        Called by SDK during initialization to enable short ref support.
+
+        Args:
+            ref_manager: RefManager instance from SDK
+        """
+        self._ref_manager = ref_manager
+
+    def get_ref(self, node_id: str) -> str | None:
+        """
+        Get short ref for a node in this collection.
+
+        Convenience method to get ref without accessing SDK directly.
+
+        Args:
+            node_id: Full node ID like "feat-a1b2c3d4"
+
+        Returns:
+            Short ref like "@f1", or None if ref manager not available
+
+        Example:
+            >>> feature = sdk.features.get("feat-abc123")
+            >>> ref = sdk.features.get_ref(feature.id)
+            >>> logger.info("%s", ref)  # "@f1"
+        """
+        if self._ref_manager:
+            result = self._ref_manager.get_ref(node_id)
+            return cast(str | None, result)
+        return None
+
     def create(
-        self,
-        title: str,
-        priority: str = "medium",
-        status: str = "todo",
-        **kwargs
-    ) -> Node:
+        self, title: str, priority: str = "medium", status: str = "todo", **kwargs: Any
+    ) -> Any:
         """
         Create a new node in this collection.
 
+        If `_builder_class` is set, returns a builder instance for fluent interface.
+        Otherwise, creates and saves a simple Node directly.
+
         Args:
             title: Node title
             priority: Priority level (low, medium, high, critical)
@@ -82,12 +255,29 @@ class BaseCollection(Generic[CollectionT]):
             **kwargs: Additional node properties
 
         Returns:
-            Created Node instance
+            Builder instance if `_builder_class` is set, else created Node instance
+
+        Raises:
+            ValueError: If node with same ID already exists (when using simple creation)
+            ValidationError: If invalid node properties provided
 
         Example:
-            >>> bug = sdk.bugs.create("Login fails", priority="critical")
-            >>> chore = sdk.chores.create("Update dependencies", priority="medium")
-        """
+            >>> # With builder (FeatureCollection, BugCollection, etc.)
+            >>> feature = sdk.features.create("User Auth") \\
+            ...     .set_priority("high") \\
+            ...     .save()
+            >>>
+            >>> # Without builder (simple collections)
+            >>> node = sdk.nodes.create("Simple task", priority="medium")
+        """
+        # If builder class is configured, use it
+        if self._builder_class is not None:
+            # Pass priority and status to builder via kwargs
+            return self._builder_class(
+                self._sdk, title, priority=priority, status=status, **kwargs
+            )
+
+        # Fallback to simple node creation
         from htmlgraph.ids import generate_id
         from htmlgraph.models import Node
 
@@ -99,9 +289,14 @@ class BaseCollection(Generic[CollectionT]):
             id=node_id,
             title=title,
             type=self._node_type,
-            priority=priority,
-            status=status,
-            **kwargs
+            priority=cast(Literal["low", "medium", "high", "critical"], priority),
+            status=cast(
+                Literal[
+                    "todo", "in-progress", "blocked", "done", "active", "ended", "stale"
+                ],
+                status,
+            ),
+            **kwargs,
         )
 
         # Add to graph
@@ -123,7 +318,7 @@ class BaseCollection(Generic[CollectionT]):
         Example:
             >>> feature = sdk.features.get("feat-001")
         """
-        return self._ensure_graph().get(node_id)
+        return cast("Node | None", self._ensure_graph().get(node_id))
 
     @contextmanager
     def edit(self, node_id: str) -> Iterator[Node]:
@@ -139,7 +334,7 @@ class BaseCollection(Generic[CollectionT]):
             The node to edit
 
         Raises:
-            ValueError: If node not found
+            NodeNotFoundError: If node not found
 
         Example:
             >>> with sdk.features.edit("feat-001") as feature:
@@ -148,7 +343,7 @@ class BaseCollection(Generic[CollectionT]):
         graph = self._ensure_graph()
         node = graph.get(node_id)
         if not node:
-            raise ValueError(f"{self._node_type.capitalize()} {node_id} not found")
+            raise NodeNotFoundError(self._node_type, node_id)
 
         yield node
 
@@ -161,7 +356,7 @@ class BaseCollection(Generic[CollectionT]):
         priority: str | None = None,
         track: str | None = None,
         assigned_to: str | None = None,
-        **extra_filters
+        **extra_filters: Any,
     ) -> list[Node]:
         """
         Query nodes with filters.
@@ -180,16 +375,17 @@ class BaseCollection(Generic[CollectionT]):
             >>> high_priority = sdk.features.where(status="todo", priority="high")
             >>> assigned = sdk.features.where(assigned_to="claude")
         """
+
         def matches(node: Node) -> bool:
             if node.type != self._node_type:
                 return False
-            if status and getattr(node, 'status', None) != status:
+            if status and getattr(node, "status", None) != status:
                 return False
-            if priority and getattr(node, 'priority', None) != priority:
+            if priority and getattr(node, "priority", None) != priority:
                 return False
             if track and getattr(node, "track_id", None) != track:
                 return False
-            if assigned_to and getattr(node, 'agent_assigned', None) != assigned_to:
+            if assigned_to and getattr(node, "agent_assigned", None) != assigned_to:
                 return False
 
             # Check extra filters
@@ -199,7 +395,41 @@ class BaseCollection(Generic[CollectionT]):
 
             return True
 
-        return self._ensure_graph().filter(matches)
+        return cast("list[Node]", self._ensure_graph().filter(matches))
+
+    def filter(self, predicate: Callable[[Node], bool]) -> list[Node]:
+        """
+        Filter nodes using a custom predicate function.
+
+        Args:
+            predicate: A callable that takes a Node and returns True if it matches
+
+        Returns:
+            List of nodes that match the predicate
+
+        Example:
+            >>> # Find features with "High" in title
+            >>> high_priority = sdk.features.filter(lambda f: "High" in f.title)
+            >>>
+            >>> # Find features created in the last week
+            >>> from datetime import datetime, timedelta
+            >>> recent = sdk.features.filter(
+            ...     lambda f: f.created > datetime.now() - timedelta(days=7)
+            ... )
+            >>>
+            >>> # Complex multi-condition filter
+            >>> urgent = sdk.features.filter(
+            ...     lambda f: f.priority == "high" and f.status == "todo"
+            ... )
+        """
+
+        def matches(node: Node) -> bool:
+            # First filter by type, then apply user predicate
+            if node.type != self._node_type:
+                return False
+            return predicate(node)
+
+        return cast("list[Node]", self._ensure_graph().filter(matches))
 
     def all(self) -> list[Node]:
         """
@@ -227,7 +457,7 @@ class BaseCollection(Generic[CollectionT]):
             >>> sdk.features.delete("feat-001")
         """
         graph = self._ensure_graph()
-        return graph.delete(node_id)
+        return cast(bool, graph.delete(node_id))
 
     def batch_delete(self, node_ids: list[str]) -> int:
         """
@@ -241,10 +471,10 @@ class BaseCollection(Generic[CollectionT]):
 
         Example:
             >>> count = sdk.features.batch_delete(["feat-001", "feat-002", "feat-003"])
-            >>> print(f"Deleted {count} features")
+            >>> logger.info(f"Deleted {count} features")
         """
         graph = self._ensure_graph()
-        return graph.batch_delete(node_ids)
+        return cast(int, graph.batch_delete(node_ids))
 
     def update(self, node: Node) -> Node:
         """
@@ -256,6 +486,9 @@ class BaseCollection(Generic[CollectionT]):
         Returns:
             Updated node
 
+        Raises:
+            NodeNotFoundError: If node doesn't exist in the graph
+
         Example:
             >>> feature.status = "done"
             >>> sdk.features.update(feature)
@@ -264,11 +497,7 @@ class BaseCollection(Generic[CollectionT]):
         self._ensure_graph().update(node)
         return node
 
-    def batch_update(
-        self,
-        node_ids: list[str],
-        updates: dict[str, Any]
-    ) -> int:
+    def batch_update(self, node_ids: list[str], updates: dict[str, Any]) -> int:
         """
         Vectorized batch update operation.
 
@@ -304,7 +533,7 @@ class BaseCollection(Generic[CollectionT]):
 
         return count
 
-    def mark_done(self, node_ids: list[str]) -> int:
+    def mark_done(self, node_ids: list[str]) -> dict[str, Any]:
         """
         Batch mark nodes as done.
 
@@ -312,12 +541,55 @@ class BaseCollection(Generic[CollectionT]):
             node_ids: List of node IDs to mark as done
 
         Returns:
-            Number of nodes updated
+            Dict with 'success_count', 'failed_ids', and 'warnings'
 
         Example:
-            >>> sdk.features.mark_done(["feat-001", "feat-002"])
+            >>> result = sdk.features.mark_done(["feat-001", "feat-002"])
+            >>> logger.info(f"Completed {result['success_count']} of {len(node_ids)}")
+            >>> if result['failed_ids']:
+            ...     logger.info(f"Failed: {result['failed_ids']}")
         """
-        return self.batch_update(node_ids, {"status": "done"})
+        graph = self._ensure_graph()
+        results: dict[str, Any] = {"success_count": 0, "failed_ids": [], "warnings": []}
+
+        for node_id in node_ids:
+            try:
+                node = graph.get(node_id)
+                if not node:
+                    results["failed_ids"].append(node_id)
+                    results["warnings"].append(f"Node {node_id} not found")
+                    continue
+
+                node.status = "done"
+                node.updated = datetime.now()
+                graph.update(node)
+                results["success_count"] += 1
+
+                # Log completion event to SQLite
+                try:
+                    self._sdk._log_event(
+                        event_type="tool_call",
+                        tool_name="SDK.mark_done",
+                        input_summary=f"Mark {self._node_type} done: {node_id}",
+                        output_summary=f"Marked {node_id} as done",
+                        context={
+                            "collection": self._collection_name,
+                            "node_id": node_id,
+                            "node_type": self._node_type,
+                            "title": node.title,
+                        },
+                        cost_tokens=25,
+                    )
+                except Exception as e:
+                    import logging
+
+                    logging.debug(f"Event logging failed for mark_done: {e}")
+
+            except Exception as e:
+                results["failed_ids"].append(node_id)
+                results["warnings"].append(f"Failed to mark {node_id}: {str(e)}")
+
+        return results
 
     def assign(self, node_ids: list[str], agent: str) -> int:
         """
@@ -333,129 +605,167 @@ class BaseCollection(Generic[CollectionT]):
         Example:
             >>> sdk.features.assign(["feat-001", "feat-002"], "claude")
         """
-        updates = {
-            "agent_assigned": agent,
-            "status": "in-progress"
-        }
+        updates = {"agent_assigned": agent, "status": "in-progress"}
         return self.batch_update(node_ids, updates)
 
     def start(self, node_id: str, agent: str | None = None) -> Node | None:
         """
         Start working on a node (feature/bug/etc).
 
-        Delegates to SessionManager to:
+        Delegates to SessionManager if available for smart tracking:
         1. Check WIP limits
         2. Ensure not claimed by others
         3. Auto-claim for agent
         4. Link to active session
         5. Log 'FeatureStart' event
 
+        Falls back to simple status update if SessionManager not available.
+
         Args:
             node_id: Node ID to start
             agent: Agent ID (defaults to SDK agent)
 
         Returns:
-            Updated Node
+            Updated Node, or None if not found
+
+        Raises:
+            NodeNotFoundError: If node not found
+
+        Example:
+            >>> sdk.features.start('feat-abc123')
+            >>> sdk.features.start('feat-xyz', agent='claude')
         """
         agent = agent or self._sdk.agent
-        
+
         # Use SessionManager if available (smart tracking)
-        if hasattr(self._sdk, 'session_manager'):
-            return self._sdk.session_manager.start_feature(
-                feature_id=node_id,
-                collection=self._collection_name,
-                agent=agent,
-                log_activity=True
+        if hasattr(self._sdk, "session_manager"):
+            return cast(
+                "Node | None",
+                self._sdk.session_manager.start_feature(
+                    feature_id=node_id,
+                    collection=self._collection_name,
+                    agent=agent,
+                    log_activity=True,
+                ),
             )
-            
+
         # Fallback to simple update (no session/events)
         node = self.get(node_id)
         if not node:
-            raise ValueError(f"Node {node_id} not found")
-            
+            raise NodeNotFoundError(self._node_type, node_id)
+
         node.status = "in-progress"
         node.updated = datetime.now()
         self._ensure_graph().update(node)
         return node
 
-    def complete(self, node_id: str, agent: str | None = None) -> Node | None:
+    def complete(
+        self,
+        node_id: str,
+        agent: str | None = None,
+        transcript_id: str | None = None,
+    ) -> Node | None:
         """
-        Complete a node.
+        Mark a node as complete.
 
-        Delegates to SessionManager to:
-        1. Update status
+        Delegates to SessionManager if available for event logging and
+        transcript linking:
+        1. Update status to 'done'
         2. Log 'FeatureComplete' event
         3. Release claim (optional behavior)
+        4. Link transcript if provided (for parallel agent tracking)
+
+        Falls back to simple status update if SessionManager not available.
 
         Args:
             node_id: Node ID to complete
             agent: Agent ID (defaults to SDK agent)
+            transcript_id: Optional transcript ID (agent session) that implemented
+                          this feature. Used for parallel agent tracking.
 
         Returns:
-            Updated Node
+            Updated Node, or None if not found
+
+        Raises:
+            NodeNotFoundError: If node not found
+
+        Example:
+            >>> sdk.features.complete('feat-abc123')
+            >>> sdk.features.complete('feat-xyz', agent='claude', transcript_id='trans-123')
         """
         agent = agent or self._sdk.agent
 
         # Use SessionManager if available
-        if hasattr(self._sdk, 'session_manager'):
-            return self._sdk.session_manager.complete_feature(
-                feature_id=node_id,
-                collection=self._collection_name,
-                agent=agent,
-                log_activity=True
+        if hasattr(self._sdk, "session_manager"):
+            return cast(
+                "Node | None",
+                self._sdk.session_manager.complete_feature(
+                    feature_id=node_id,
+                    collection=self._collection_name,
+                    agent=agent,
+                    log_activity=True,
+                    transcript_id=transcript_id,
+                ),
             )
 
         # Fallback
         node = self.get(node_id)
         if not node:
-            raise ValueError(f"Node {node_id} not found")
+            raise NodeNotFoundError(self._node_type, node_id)
 
         node.status = "done"
         node.updated = datetime.now()
         self._ensure_graph().update(node)
         return node
 
-    def claim(self, node_id: str, agent: str | None = None) -> Node:
+    def claim(self, node_id: str, agent: str | None = None) -> Node | None:
         """
         Claim a node for an agent.
 
-        Delegates to SessionManager to:
+        Delegates to SessionManager if available for ownership tracking:
         1. Check ownership rules
         2. Update assignment
         3. Log 'FeatureClaim' event
 
+        Falls back to simple assignment if SessionManager not available.
+
         Args:
             node_id: Node ID to claim
             agent: Agent ID (defaults to SDK agent)
 
         Returns:
-            The claimed Node
+            The claimed Node, or None if not found
 
         Raises:
             ValueError: If agent not provided and SDK has no agent
-            ValueError: If node not found
-            ValueError: If node already claimed by different agent
+            NodeNotFoundError: If node not found
+            ClaimConflictError: If node already claimed by different agent
+
+        Example:
+            >>> sdk.features.claim('feat-abc123')
+            >>> sdk.features.claim('feat-xyz', agent='claude')
         """
         agent = agent or self._sdk.agent
         if not agent:
             raise ValueError("Agent ID required for claiming")
 
         # Use SessionManager if available
-        if hasattr(self._sdk, 'session_manager'):
-            return self._sdk.session_manager.claim_feature(
-                feature_id=node_id,
-                collection=self._collection_name,
-                agent=agent
+        if hasattr(self._sdk, "session_manager"):
+            return cast(
+                "Node | None",
+                self._sdk.session_manager.claim_feature(
+                    feature_id=node_id, collection=self._collection_name, agent=agent
+                ),
             )
 
         # Fallback logic
         graph = self._ensure_graph()
-        node = graph.get(node_id)
+        node = cast("Node | None", graph.get(node_id))
         if not node:
-            raise ValueError(f"Node {node_id} not found")
+            raise NodeNotFoundError(self._node_type, node_id)
 
         if node.agent_assigned and node.agent_assigned != agent:
-            raise ValueError(f"Node {node_id} is already claimed by {node.agent_assigned}")
+            raise ClaimConflictError(node_id, node.agent_assigned)
 
         node.agent_assigned = agent
         node.claimed_at = datetime.now()
@@ -464,41 +774,48 @@ class BaseCollection(Generic[CollectionT]):
         graph.update(node)
         return node
 
-    def release(self, node_id: str, agent: str | None = None) -> Node:
+    def release(self, node_id: str, agent: str | None = None) -> Node | None:
         """
         Release a claimed node.
 
-        Delegates to SessionManager to:
+        Delegates to SessionManager if available for ownership tracking:
         1. Verify ownership
         2. Clear assignment
         3. Log 'FeatureRelease' event
 
+        Falls back to simple assignment clearing if SessionManager not available.
+
         Args:
             node_id: Node ID to release
             agent: Agent ID (defaults to SDK agent)
 
         Returns:
-            The released Node
+            The released Node, or None if not found
 
         Raises:
-            ValueError: If node not found
+            NodeNotFoundError: If node not found
+
+        Example:
+            >>> sdk.features.release('feat-abc123')
+            >>> sdk.features.release('feat-xyz', agent='claude')
         """
         # SessionManager.release_feature requires an agent to verify ownership
         agent = agent or self._sdk.agent
-        
+
         # Use SessionManager if available
-        if hasattr(self._sdk, 'session_manager') and agent:
-            return self._sdk.session_manager.release_feature(
-                feature_id=node_id,
-                collection=self._collection_name,
-                agent=agent
+        if hasattr(self._sdk, "session_manager") and agent:
+            return cast(
+                "Node | None",
+                self._sdk.session_manager.release_feature(
+                    feature_id=node_id, collection=self._collection_name, agent=agent
+                ),
             )
 
         # Fallback logic
         graph = self._ensure_graph()
-        node = graph.get(node_id)
+        node = cast("Node | None", graph.get(node_id))
         if not node:
-            raise ValueError(f"Node {node_id} not found")
+            raise NodeNotFoundError(self._node_type, node_id)
 
         node.agent_assigned = None
         node.claimed_at = None
@@ -506,4 +823,4 @@ class BaseCollection(Generic[CollectionT]):
         node.status = "todo"
         node.updated = datetime.now()
         graph.update(node)
-        return node
+        return node