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

htmlgraph/converter.py

@@ -8,22 +8,34 @@ Provides:
 - Handles edge cases (missing fields, malformed HTML)
 """
 
+import logging
 from pathlib import Path
-from typing import Any
-
-from htmlgraph.models import Node, Edge, Step, Session, ActivityEntry
+from typing import Any, cast
+
+from htmlgraph.models import (
+    ActivityEntry,
+    Chore,
+    Edge,
+    Node,
+    Pattern,
+    Session,
+    Spike,
+    Step,
+)
 from htmlgraph.parser import HtmlParser
 
+logger = logging.getLogger(__name__)
+
 
 def html_to_node(filepath: Path | str) -> Node:
     """
-    Parse HTML file into a Node model.
+    Parse HTML file into a Node model (or subclass).
 
     Args:
         filepath: Path to HTML file
 
     Returns:
-        Node instance populated from HTML
+        Node instance (or Spike/Chore subclass) populated from HTML
 
     Raises:
         FileNotFoundError: If file doesn't exist
@@ -66,14 +78,24 @@ def html_to_node(filepath: Path | str) -> Node:
     ]
     data["steps"] = steps
 
-    return Node(**data)
+    # Map node type to model class
+    node_type = data.get("type", "node")
+    model_classes: dict[str, type[Node]] = {
+        "spike": Spike,
+        "chore": Chore,
+        "pattern": Pattern,
+        "node": Node,
+    }
+
+    model_class = model_classes.get(node_type, Node)
+    return cast(Node, model_class(**data))
 
 
 def node_to_html(
     node: Node,
     filepath: Path | str,
     stylesheet_path: str = "../styles.css",
-    create_dirs: bool = True
+    create_dirs: bool = True,
 ) -> Path:
     """
     Write a Node model to an HTML file.
@@ -101,7 +123,7 @@ def node_to_html(
 def update_node_html(
     filepath: Path | str,
     updates: dict[str, Any],
-    stylesheet_path: str = "../styles.css"
+    stylesheet_path: str = "../styles.css",
 ) -> Node:
     """
     Update specific fields in an existing HTML node file.
@@ -195,7 +217,8 @@ def node_to_dict(node: Node) -> dict[str, Any]:
         if step.get("timestamp"):
             step["timestamp"] = step["timestamp"].isoformat()
 
-    return data
+    result: dict[str, Any] = data
+    return result
 
 
 def dict_to_node(data: dict[str, Any]) -> Node:
@@ -215,12 +238,16 @@ def dict_to_node(data: dict[str, Any]) -> Node:
     for edges in data.get("edges", {}).values():
         for edge in edges:
             if isinstance(edge.get("since"), str):
-                edge["since"] = datetime.fromisoformat(edge["since"].replace("Z", "+00:00"))
+                edge["since"] = datetime.fromisoformat(
+                    edge["since"].replace("Z", "+00:00")
+                )
 
     # Parse step datetimes
     for step in data.get("steps", []):
         if isinstance(step.get("timestamp"), str):
-            step["timestamp"] = datetime.fromisoformat(step["timestamp"].replace("Z", "+00:00"))
+            step["timestamp"] = datetime.fromisoformat(
+                step["timestamp"].replace("Z", "+00:00")
+            )
 
     return Node.from_dict(data)
 
@@ -299,6 +326,7 @@ class NodeConverter:
 # Session Converters
 # =============================================================================
 
+
 def session_to_dict(session: Session) -> dict[str, Any]:
     """
     Convert Session to a plain dictionary (JSON-serializable).
@@ -317,7 +345,8 @@ def session_to_dict(session: Session) -> dict[str, Any]:
         if entry.get("timestamp"):
             entry["timestamp"] = entry["timestamp"].isoformat()
 
-    return data
+    result: dict[str, Any] = data
+    return result
 
 
 def dict_to_session(data: dict[str, Any]) -> Session:
@@ -336,7 +365,9 @@ def dict_to_session(data: dict[str, Any]) -> Session:
     # Parse activity log timestamps
     for entry in data.get("activity_log", []):
         if isinstance(entry.get("timestamp"), str):
-            entry["timestamp"] = datetime.fromisoformat(entry["timestamp"].replace("Z", "+00:00"))
+            entry["timestamp"] = datetime.fromisoformat(
+                entry["timestamp"].replace("Z", "+00:00")
+            )
 
     return Session.from_dict(data)
 
@@ -364,7 +395,8 @@ def html_to_session(filepath: Path | str) -> Session:
     parser = HtmlParser.from_file(filepath)
 
     # Get article element with session data
-    article = parser.query_one("article[data-type='session']")
+    article_results = parser.query("article[data-type='session']")
+    article = article_results[0] if article_results else None
     if not article:
         raise ValueError(f"No session article found in: {filepath}")
 
@@ -392,7 +424,9 @@ def html_to_session(filepath: Path | str) -> Session:
 
     last_activity = article.attrs.get("data-last-activity")
     if last_activity:
-        data["last_activity"] = datetime.fromisoformat(last_activity.replace("Z", "+00:00"))
+        data["last_activity"] = datetime.fromisoformat(
+            last_activity.replace("Z", "+00:00")
+        )
 
     start_commit = article.attrs.get("data-start-commit")
     if start_commit:
@@ -406,19 +440,42 @@ def html_to_session(filepath: Path | str) -> Session:
     work_breakdown_json = article.attrs.get("data-work-breakdown")
     if work_breakdown_json:
         import json
+
         try:
             data["work_breakdown"] = json.loads(work_breakdown_json)
         except (json.JSONDecodeError, ValueError):
             pass  # Skip if invalid JSON
 
+    # Parse transcript integration fields
+    transcript_id = article.attrs.get("data-transcript-id")
+    if transcript_id:
+        data["transcript_id"] = transcript_id
+
+    transcript_path = article.attrs.get("data-transcript-path")
+    if transcript_path:
+        data["transcript_path"] = transcript_path
+
+    transcript_synced = article.attrs.get("data-transcript-synced")
+    if transcript_synced:
+        data["transcript_synced_at"] = datetime.fromisoformat(
+            transcript_synced.replace("Z", "+00:00")
+        )
+
+    transcript_branch = article.attrs.get("data-transcript-branch")
+    if transcript_branch:
+        data["transcript_git_branch"] = transcript_branch
+
     # Parse title
-    title_el = parser.query_one("h1")
+    title_el_results = parser.query("h1")
+    title_el = title_el_results[0] if title_el_results else None
     if title_el:
         data["title"] = title_el.to_text().strip()
 
     # Parse worked_on edges
     worked_on = []
-    for link in parser.query("nav[data-graph-edges] section[data-edge-type='worked-on'] a"):
+    for link in parser.query(
+        "nav[data-graph-edges] section[data-edge-type='worked-on'] a"
+    ):
         href = link.attrs.get("href") or ""
         # Extract feature ID from href
         feature_id = href.replace("../features/", "").replace(".html", "")
@@ -427,22 +484,28 @@ def html_to_session(filepath: Path | str) -> Session:
     data["worked_on"] = worked_on
 
     # Parse continued_from edge
-    continued_link = parser.query_one("nav[data-graph-edges] section[data-edge-type='continued-from'] a")
+    continued_link_results = parser.query(
+        "nav[data-graph-edges] section[data-edge-type='continued-from'] a"
+    )
+    continued_link = continued_link_results[0] if continued_link_results else None
     if continued_link:
         href = continued_link.attrs.get("href") or ""
         data["continued_from"] = href.replace(".html", "")
 
     # Parse handoff context
-    handoff_section = parser.query_one("section[data-handoff]")
+    handoff_section_results = parser.query("section[data-handoff]")
+    handoff_section = handoff_section_results[0] if handoff_section_results else None
     if handoff_section:
-        notes_el = parser.query_one("section[data-handoff] [data-handoff-notes]")
+        notes_el_results = parser.query("section[data-handoff] [data-handoff-notes]")
+        notes_el = notes_el_results[0] if notes_el_results else None
         if notes_el:
             notes_text = notes_el.to_text().strip()
             if notes_text.lower().startswith("notes:"):
                 notes_text = notes_text.split(":", 1)[1].strip()
             data["handoff_notes"] = notes_text
 
-        next_el = parser.query_one("section[data-handoff] [data-recommended-next]")
+        next_el_results = parser.query("section[data-handoff] [data-recommended-next]")
+        next_el = next_el_results[0] if next_el_results else None
         if next_el:
             next_text = next_el.to_text().strip()
             if next_text.lower().startswith("recommended next:"):
@@ -457,6 +520,17 @@ def html_to_session(filepath: Path | str) -> Session:
         if blockers:
             data["blockers"] = blockers
 
+        # Parse recommended context files
+        recommended_context = []
+        for li in parser.query(
+            "section[data-handoff] div[data-recommended-context] li"
+        ):
+            file_path = li.to_text().strip()
+            if file_path:
+                recommended_context.append(file_path)
+        if recommended_context:
+            data["recommended_context"] = recommended_context
+
     # Parse activity log
     activity_log = []
     for li in parser.query("section[data-activity-log] ol li"):
@@ -491,6 +565,88 @@ def html_to_session(filepath: Path | str) -> Session:
     # Activity log in HTML is reversed (newest first), so reverse back
     data["activity_log"] = list(reversed(activity_log))
 
+    # Parse detected patterns from table (if present)
+    detected_patterns = []
+    for tr in parser.query("section[data-detected-patterns] table tbody tr"):
+        # Extract pattern data from table row
+        pattern_type = tr.attrs.get("data-pattern-type", "neutral")
+
+        # Extract sequence from first <td class="sequence">
+        seq_tds = tr.query("td.sequence")
+        seq_td = seq_tds[0] if seq_tds else None
+        sequence_str = seq_td.to_text().strip() if seq_td else ""
+        sequence = [s.strip() for s in sequence_str.split("→")] if sequence_str else []
+
+        # Extract count from third <td>
+        tds = tr.query("td")
+        count_td = tds[2] if len(tds) > 2 else None
+        count_str = count_td.to_text().strip() if count_td else "0"
+        try:
+            count = int(count_str)
+        except (ValueError, TypeError):
+            count = 0
+
+        # Extract timestamps from fourth <td>
+        time_td = tds[3] if len(tds) > 3 else None
+        time_str = time_td.to_text().strip() if time_td else ""
+        times = time_str.split(" / ")
+        first_detected = times[0].strip() if len(times) > 0 else ""
+        last_detected = times[1].strip() if len(times) > 1 else ""
+
+        if sequence:  # Only add if we have a valid sequence
+            detected_patterns.append(
+                {
+                    "sequence": sequence,
+                    "pattern_type": pattern_type,
+                    "detection_count": count,
+                    "first_detected": first_detected,
+                    "last_detected": last_detected,
+                }
+            )
+
+    data["detected_patterns"] = detected_patterns
+
+    # Parse error log from error section (if present)
+    error_log = []
+    for details in parser.query("section[data-error-log] details"):
+        error_data = {
+            "error_type": details.attrs.get("data-error-type", "Unknown"),
+            "message": "",
+            "traceback": None,
+        }
+
+        ts = details.attrs.get("data-ts")
+        if ts:
+            error_data["timestamp"] = datetime.fromisoformat(ts.replace("Z", "+00:00"))
+
+        tool = details.attrs.get("data-tool")
+        if tool:
+            error_data["tool"] = tool
+
+        # Parse summary text (first line of details)
+        summary_el_results = details.query("summary")
+        summary_el = summary_el_results[0] if summary_el_results else None
+        if summary_el:
+            summary_text = summary_el.to_text().strip()
+            # Extract message from "ErrorType: message" format
+            if ": " in summary_text:
+                error_data["message"] = summary_text.split(": ", 1)[1]
+            else:
+                error_data["message"] = summary_text
+
+        # Parse traceback (if present)
+        traceback_el_results = details.query("pre.traceback")
+        traceback_el = traceback_el_results[0] if traceback_el_results else None
+        if traceback_el:
+            error_data["traceback"] = traceback_el.to_text().strip()
+
+        if error_data.get("message") or error_data.get("traceback"):
+            from htmlgraph.models import ErrorEntry
+
+            error_log.append(ErrorEntry(**error_data))
+
+    data["error_log"] = error_log
+
     return Session(**data)
 
 
@@ -498,7 +654,7 @@ def session_to_html(
     session: Session,
     filepath: Path | str,
     stylesheet_path: str = "../styles.css",
-    create_dirs: bool = True
+    create_dirs: bool = True,
 ) -> Path:
     """
     Write a Session model to an HTML file.
@@ -538,18 +694,50 @@ class SessionConverter:
         self.stylesheet_path = stylesheet_path
 
     def load(self, session_id: str) -> Session | None:
-        """Load a single session by ID."""
+        """
+        Load a single session by ID and cleanup stale work item references.
+
+        This automatically removes references to deleted/missing work items
+        from the session's worked_on list to maintain data integrity.
+        """
         filepath = self.directory / f"{session_id}.html"
-        if filepath.exists():
-            return html_to_session(filepath)
-        return None
+        if not filepath.exists():
+            return None
+
+        # Load session from HTML
+        session = html_to_session(filepath)
+
+        # Cleanup stale work item references
+        # (removes IDs from worked_on that no longer exist in .htmlgraph/)
+        graph_dir = self.directory.parent  # .htmlgraph directory
+        cleanup_result = session.cleanup_missing_references(graph_dir)
+
+        # Log warning if stale references were removed
+        if cleanup_result["removed_count"] > 0:
+            logger.warning(
+                f"Session {session_id}: Removed {cleanup_result['removed_count']} "
+                f"stale work item references: {cleanup_result['removed']}"
+            )
+            # Save cleaned session back to disk
+            self.save(session)
+
+        return session
 
     def load_all(self, pattern: str = "*.html") -> list[Session]:
-        """Load all sessions matching pattern."""
+        """
+        Load all sessions matching pattern and cleanup stale references.
+
+        Each session is loaded through self.load() which automatically cleans up
+        stale work item references.
+        """
         sessions = []
         for filepath in self.directory.glob(pattern):
             try:
-                sessions.append(html_to_session(filepath))
+                # Extract session_id from filename
+                session_id = filepath.stem  # e.g., "sess-abc123"
+                session = self.load(session_id)
+                if session:
+                    sessions.append(session)
             except (ValueError, KeyError):
                 continue
         return sessions

htmlgraph/cost_analysis/__init__.py

@@ -0,0 +1,5 @@
+"""Cost analysis module for HtmlGraph event tracking and token cost calculation."""
+
+from .analyzer import CostAnalyzer
+
+__all__ = ["CostAnalyzer"]