htmlgraph 0.27.6__tar.gz → 0.28.0__tar.gz

{htmlgraph-0.27.6 → htmlgraph-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlgraph
-Version: 0.27.6
+Version: 0.28.0
 Summary: HTML is All You Need - Graph database on web standards
 Project-URL: Homepage, https://github.com/Shakes-tzd/htmlgraph
 Project-URL: Documentation, https://github.com/Shakes-tzd/htmlgraph#readme

{htmlgraph-0.27.6 → htmlgraph-0.28.0}/packages/gemini-extension/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "htmlgraph",
-  "version": "0.27.6",
+  "version": "0.28.0",
   "description": "HtmlGraph session tracking and documentation for Gemini CLI. Ensures proper activity attribution, feature awareness, and continuous work tracking.",
   "author": "Shakes",
   "license": "MIT",

{htmlgraph-0.27.6 → htmlgraph-0.28.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "htmlgraph"
-version = "0.27.6"
+version = "0.28.0"
 description = "HTML is All You Need - Graph database on web standards"
 authors = [{name = "Shakes", email = "shakestzd@gmail.com"}]
 readme = "README.md"

{htmlgraph-0.27.6 → htmlgraph-0.28.0}/src/python/htmlgraph/__init__.py

@@ -90,6 +90,11 @@ from htmlgraph.reflection import ComputationalReflection, get_reflection_context
 from htmlgraph.repo_hash import RepoHash
 from htmlgraph.sdk import SDK
 from htmlgraph.server import serve
+from htmlgraph.session_context import (
+    GitHooksInstaller,
+    SessionContextBuilder,
+    VersionChecker,
+)
 from htmlgraph.session_manager import SessionManager
 from htmlgraph.session_registry import SessionRegistry
 from htmlgraph.types import (
@@ -118,7 +123,7 @@ from htmlgraph.types import (
 )
 from htmlgraph.work_type_utils import infer_work_type, infer_work_type_from_id
 
-__version__ = "0.27.6"
+__version__ = "0.28.0"
 __all__ = [
     # Exceptions
     "HtmlGraphError",
@@ -160,6 +165,9 @@ __all__ = [
     "find_all",
     "AgentInterface",
     "SessionManager",
+    "SessionContextBuilder",
+    "VersionChecker",
+    "GitHooksInstaller",
     "SessionRegistry",
     "RepoHash",
     "SDK",

htmlgraph-0.28.0/src/python/htmlgraph/api/broadcast.py

@@ -0,0 +1,316 @@
+"""
+Cross-Session Broadcast Sync - Phase 2
+
+Enables real-time feature updates across multiple Claude Code sessions.
+Session A updates a feature → immediately visible in Session B without manual git pull.
+
+Features:
+- Real-time feature/track/spike updates (<100ms latency)
+- Cross-session coordination
+- Automatic synchronization
+- Audit trail for all changes
+"""
+
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class BroadcastEventType(str, Enum):
+    """Types of broadcast events for cross-session sync."""
+
+    FEATURE_UPDATED = "feature_updated"
+    FEATURE_CREATED = "feature_created"
+    FEATURE_DELETED = "feature_deleted"
+    TRACK_UPDATED = "track_updated"
+    SPIKE_UPDATED = "spike_updated"
+    STATUS_CHANGED = "status_changed"
+    LINK_ADDED = "link_added"
+    COMMENT_ADDED = "comment_added"
+
+
+@dataclass
+class BroadcastEvent:
+    """
+    Event for cross-session broadcasting.
+
+    Contains all information needed to synchronize changes across
+    multiple active sessions.
+    """
+
+    event_type: BroadcastEventType
+    resource_id: str  # feature_id, track_id, etc.
+    resource_type: str  # "feature", "track", "spike"
+    agent_id: str
+    session_id: str
+    payload: dict[str, Any]
+    timestamp: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "type": "broadcast_event",
+            "event_type": self.event_type.value,
+            "resource_id": self.resource_id,
+            "resource_type": self.resource_type,
+            "agent_id": self.agent_id,
+            "session_id": self.session_id,
+            "payload": self.payload,
+            "timestamp": self.timestamp.isoformat(),
+        }
+
+
+class CrossSessionBroadcaster:
+    """
+    Broadcasts feature/track/spike updates across all active sessions.
+
+    Enables real-time coordination between multiple agents working
+    on the same project simultaneously.
+
+    Example:
+        >>> broadcaster = CrossSessionBroadcaster(websocket_manager, db_path)
+        >>> await broadcaster.broadcast_feature_update(
+        ...     feature_id="feat-123",
+        ...     agent_id="claude-1",
+        ...     session_id="sess-1",
+        ...     payload={"status": "in_progress"}
+        ... )
+        >>> # All other sessions immediately see the update
+    """
+
+    def __init__(self, websocket_manager: Any, db_path: str):
+        """
+        Initialize broadcaster.
+
+        Args:
+            websocket_manager: WebSocketManager instance for distribution
+            db_path: Path to SQLite database for audit trail
+        """
+        self.websocket_manager = websocket_manager
+        self.db_path = db_path
+        self.event_cache: dict[str, float] = {}  # Simple deduplication cache
+
+    async def broadcast_feature_update(
+        self,
+        feature_id: str,
+        agent_id: str,
+        session_id: str,
+        payload: dict[str, Any],
+    ) -> int:
+        """
+        Broadcast feature update to all sessions.
+
+        Args:
+            feature_id: Feature being updated
+            agent_id: Agent making the change
+            session_id: Source session
+            payload: Update details (title, status, description, etc.)
+
+        Returns:
+            Number of clients that received the broadcast
+        """
+        event = BroadcastEvent(
+            event_type=BroadcastEventType.FEATURE_UPDATED,
+            resource_id=feature_id,
+            resource_type="feature",
+            agent_id=agent_id,
+            session_id=session_id,
+            payload=payload,
+        )
+
+        # Broadcast to all sessions
+        clients_notified = await self.websocket_manager.broadcast_to_all_sessions(
+            event.to_dict()
+        )
+
+        logger.info(
+            f"Broadcast feature {feature_id} update to {clients_notified} clients "
+            f"(agent={agent_id}, session={session_id})"
+        )
+
+        return int(clients_notified)
+
+    async def broadcast_feature_created(
+        self,
+        feature_id: str,
+        agent_id: str,
+        session_id: str,
+        payload: dict[str, Any],
+    ) -> int:
+        """
+        Broadcast new feature creation to all sessions.
+
+        Args:
+            feature_id: New feature ID
+            agent_id: Agent creating the feature
+            session_id: Source session
+            payload: Feature details
+
+        Returns:
+            Number of clients notified
+        """
+        event = BroadcastEvent(
+            event_type=BroadcastEventType.FEATURE_CREATED,
+            resource_id=feature_id,
+            resource_type="feature",
+            agent_id=agent_id,
+            session_id=session_id,
+            payload=payload,
+        )
+
+        clients_notified = await self.websocket_manager.broadcast_to_all_sessions(
+            event.to_dict()
+        )
+
+        logger.info(
+            f"Broadcast new feature {feature_id} to {clients_notified} clients "
+            f"(agent={agent_id})"
+        )
+
+        return int(clients_notified)
+
+    async def broadcast_status_change(
+        self,
+        feature_id: str,
+        old_status: str,
+        new_status: str,
+        agent_id: str,
+        session_id: str,
+    ) -> int:
+        """
+        Broadcast feature status change across sessions.
+
+        Args:
+            feature_id: Feature being updated
+            old_status: Previous status
+            new_status: New status
+            agent_id: Agent making change
+            session_id: Source session
+
+        Returns:
+            Number of clients notified
+        """
+        return await self.broadcast_feature_update(
+            feature_id=feature_id,
+            agent_id=agent_id,
+            session_id=session_id,
+            payload={
+                "change_type": "status",
+                "old_status": old_status,
+                "new_status": new_status,
+            },
+        )
+
+    async def broadcast_link_added(
+        self,
+        feature_id: str,
+        linked_feature_id: str,
+        link_type: str,  # "depends_on", "blocks", "related", etc.
+        agent_id: str,
+        session_id: str,
+    ) -> int:
+        """
+        Broadcast when feature links are added.
+
+        Args:
+            feature_id: Source feature
+            linked_feature_id: Target feature
+            link_type: Type of relationship
+            agent_id: Agent making change
+            session_id: Source session
+
+        Returns:
+            Number of clients notified
+        """
+        return await self.broadcast_feature_update(
+            feature_id=feature_id,
+            agent_id=agent_id,
+            session_id=session_id,
+            payload={
+                "change_type": "link_added",
+                "linked_feature_id": linked_feature_id,
+                "link_type": link_type,
+            },
+        )
+
+    async def broadcast_track_update(
+        self,
+        track_id: str,
+        agent_id: str,
+        session_id: str,
+        payload: dict[str, Any],
+    ) -> int:
+        """
+        Broadcast track update to all sessions.
+
+        Args:
+            track_id: Track being updated
+            agent_id: Agent making change
+            session_id: Source session
+            payload: Update details
+
+        Returns:
+            Number of clients notified
+        """
+        event = BroadcastEvent(
+            event_type=BroadcastEventType.TRACK_UPDATED,
+            resource_id=track_id,
+            resource_type="track",
+            agent_id=agent_id,
+            session_id=session_id,
+            payload=payload,
+        )
+
+        clients_notified = await self.websocket_manager.broadcast_to_all_sessions(
+            event.to_dict()
+        )
+
+        logger.info(
+            f"Broadcast track {track_id} update to {clients_notified} clients "
+            f"(agent={agent_id})"
+        )
+
+        return int(clients_notified)
+
+    async def broadcast_spike_update(
+        self,
+        spike_id: str,
+        agent_id: str,
+        session_id: str,
+        payload: dict[str, Any],
+    ) -> int:
+        """
+        Broadcast spike update to all sessions.
+
+        Args:
+            spike_id: Spike being updated
+            agent_id: Agent making change
+            session_id: Source session
+            payload: Update details
+
+        Returns:
+            Number of clients notified
+        """
+        event = BroadcastEvent(
+            event_type=BroadcastEventType.SPIKE_UPDATED,
+            resource_id=spike_id,
+            resource_type="spike",
+            agent_id=agent_id,
+            session_id=session_id,
+            payload=payload,
+        )
+
+        clients_notified = await self.websocket_manager.broadcast_to_all_sessions(
+            event.to_dict()
+        )
+
+        logger.info(
+            f"Broadcast spike {spike_id} update to {clients_notified} clients "
+            f"(agent={agent_id})"
+        )
+
+        return int(clients_notified)