htmlgraph 0.26.12__py3-none-any.whl → 0.26.14__py3-none-any.whl

htmlgraph/__init__.py

@@ -95,7 +95,7 @@ from htmlgraph.types import (
 )
 from htmlgraph.work_type_utils import infer_work_type, infer_work_type_from_id
 
-__version__ = "0.26.12"
+__version__ = "0.26.14"
 __all__ = [
     # Exceptions
     "HtmlGraphError",

htmlgraph/analytics/__init__.py

@@ -1,9 +1,12 @@
 """
 Analytics modules for HtmlGraph.
 
-Provides work type analysis, dependency analytics, cross-session analytics, and CLI analytics.
+Provides work type analysis, dependency analytics, cross-session analytics, CLI analytics,
+and cost attribution analysis for OTEL ROI.
 """
 
+from htmlgraph.analytics.cost_analyzer import CostAnalyzer
+from htmlgraph.analytics.cost_reporter import CostReporter
 from htmlgraph.analytics.cross_session import CrossSessionAnalytics
 from htmlgraph.analytics.dependency import DependencyAnalytics
 from htmlgraph.analytics.work_type import Analytics
@@ -12,4 +15,6 @@ __all__ = [
     "Analytics",
     "DependencyAnalytics",
     "CrossSessionAnalytics",
+    "CostAnalyzer",
+    "CostReporter",
 ]

htmlgraph/analytics/cost_analyzer.py

@@ -0,0 +1,387 @@
+"""
+CostAnalyzer for OTEL ROI Analysis - Phase 1.
+
+Analyzes cost attribution of Task() delegations vs direct tool execution.
+Provides insights into which delegations are most expensive and their ROI.
+
+Components:
+1. get_task_delegations() - Query all task_delegation events with hierarchy
+2. calculate_task_cost(event_id) - Sum token costs of all child tool calls
+3. get_cost_by_subagent_type() - Group costs by subagent type
+4. get_cost_by_tool_type() - Show which tools cost most
+5. get_roi_stats() - Calculate parallelization savings and benefits
+
+Usage:
+    from htmlgraph.analytics.cost_analyzer import CostAnalyzer
+    analyzer = CostAnalyzer()
+    delegations = analyzer.get_task_delegations_with_costs()
+    print(f"Total delegation cost: ${delegations['total_cost_usd']:.2f}")
+"""
+
+import sqlite3
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from htmlgraph.cigs.cost import CostCalculator
+
+
+@dataclass
+class TaskDelegation:
+    """Represents a single Task delegation with cost analysis."""
+
+    event_id: str
+    session_id: str
+    timestamp: datetime
+    subagent_type: str
+    parent_event_id: str | None
+    tool_count: int = 0
+    total_cost_tokens: int = 0
+    child_events: list[dict[str, Any]] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "event_id": self.event_id,
+            "session_id": self.session_id,
+            "timestamp": self.timestamp.isoformat(),
+            "subagent_type": self.subagent_type,
+            "parent_event_id": self.parent_event_id,
+            "tool_count": self.tool_count,
+            "total_cost_tokens": self.total_cost_tokens,
+            "child_events": self.child_events,
+        }
+
+
+@dataclass
+class CostBreakdown:
+    """Cost breakdown analysis."""
+
+    by_subagent: dict[str, int] = field(default_factory=dict)
+    by_tool: dict[str, int] = field(default_factory=dict)
+    total_cost_tokens: int = 0
+    total_delegations: int = 0
+    avg_cost_per_delegation: float = 0.0
+
+
+@dataclass
+class ROIStats:
+    """Return-on-Investment statistics."""
+
+    total_delegation_cost: int = 0
+    estimated_direct_cost: int = 0
+    estimated_savings: int = 0
+    savings_percentage: float = 0.0
+    avg_parallelization_factor: float = 1.0
+    context_preservation_benefit: float = 0.0
+    total_delegations: int = 0
+    avg_cost_per_delegation: float = 0.0
+
+
+class CostAnalyzer:
+    """
+    Analyze cost attribution of Task delegations.
+
+    Queries the agent_events database to calculate:
+    - Total cost of each Task delegation (sum of child tool calls)
+    - Cost breakdown by subagent type and tool type
+    - ROI statistics comparing direct vs delegated execution
+    """
+
+    def __init__(self, graph_dir: Path | None = None):
+        """
+        Initialize CostAnalyzer.
+
+        Args:
+            graph_dir: Root directory for HtmlGraph (defaults to .htmlgraph)
+        """
+        if graph_dir is None:
+            graph_dir = Path.cwd() / ".htmlgraph"
+
+        self.graph_dir = Path(graph_dir)
+        self.db_path = self.graph_dir / "htmlgraph.db"
+        self.cost_calculator = CostCalculator()
+
+        if not self.db_path.exists():
+            raise FileNotFoundError(f"Database not found at {self.db_path}")
+
+    def _get_connection(self) -> sqlite3.Connection:
+        """Get database connection with row factory."""
+        conn = sqlite3.connect(str(self.db_path))
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def get_task_delegations(self) -> list[TaskDelegation]:
+        """
+        Query all task_delegation events from the database.
+
+        Returns:
+            List of TaskDelegation objects ordered by timestamp (newest first)
+        """
+        conn = self._get_connection()
+        try:
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                SELECT
+                    event_id,
+                    session_id,
+                    timestamp,
+                    subagent_type,
+                    parent_event_id
+                FROM agent_events
+                WHERE event_type = 'task_delegation'
+                ORDER BY timestamp DESC
+                """
+            )
+
+            delegations = []
+            for row in cursor.fetchall():
+                timestamp = (
+                    datetime.fromisoformat(row["timestamp"])
+                    if isinstance(row["timestamp"], str)
+                    else row["timestamp"]
+                )
+                delegations.append(
+                    TaskDelegation(
+                        event_id=row["event_id"],
+                        session_id=row["session_id"],
+                        timestamp=timestamp,
+                        subagent_type=row["subagent_type"] or "unknown",
+                        parent_event_id=row["parent_event_id"],
+                    )
+                )
+
+            return delegations
+        finally:
+            conn.close()
+
+    def calculate_task_cost(self, event_id: str) -> tuple[int, list[dict[str, Any]]]:
+        """
+        Calculate total cost of a Task delegation.
+
+        Sums all token costs of child tool calls using cost_tokens field.
+        Falls back to CIGS cost estimation if cost_tokens is not available.
+
+        Args:
+            event_id: Task delegation event ID
+
+        Returns:
+            Tuple of (total_cost_tokens, child_events_list)
+        """
+        conn = self._get_connection()
+        try:
+            cursor = conn.cursor()
+
+            # Get all children of this task
+            cursor.execute(
+                """
+                SELECT
+                    event_id,
+                    tool_name,
+                    cost_tokens,
+                    input_summary,
+                    output_summary,
+                    timestamp
+                FROM agent_events
+                WHERE parent_event_id = ?
+                AND event_type IN ('tool_call', 'tool_result')
+                ORDER BY timestamp ASC
+                """,
+                (event_id,),
+            )
+
+            total_cost = 0
+            child_events = []
+
+            for row in cursor.fetchall():
+                cost = row["cost_tokens"] if row["cost_tokens"] else 0
+
+                # If no stored cost, estimate based on tool type
+                if cost == 0 and row["tool_name"]:
+                    cost = self.cost_calculator.predict_cost(row["tool_name"], {})
+
+                total_cost += cost
+
+                child_events.append(
+                    {
+                        "event_id": row["event_id"],
+                        "tool_name": row["tool_name"],
+                        "cost_tokens": cost,
+                        "timestamp": row["timestamp"],
+                    }
+                )
+
+            return total_cost, child_events
+        finally:
+            conn.close()
+
+    def get_task_delegations_with_costs(self) -> dict[str, Any]:
+        """
+        Get all task delegations with calculated costs.
+
+        Returns:
+            Dictionary with:
+            - delegations: List of TaskDelegation with costs
+            - total_cost_tokens: Sum of all delegation costs
+            - total_delegations: Count of delegations
+            - by_subagent_type: Cost breakdown by subagent
+            - by_tool_type: Cost breakdown by tool
+        """
+        delegations = self.get_task_delegations()
+
+        total_cost = 0
+        by_subagent: dict[str, int] = {}
+        by_tool: dict[str, int] = {}
+
+        for delegation in delegations:
+            cost, child_events = self.calculate_task_cost(delegation.event_id)
+            delegation.total_cost_tokens = cost
+            delegation.child_events = child_events
+            delegation.tool_count = len(child_events)
+
+            total_cost += cost
+
+            # Track by subagent type
+            subagent = delegation.subagent_type
+            by_subagent[subagent] = by_subagent.get(subagent, 0) + cost
+
+            # Track by tool type
+            for child in child_events:
+                tool = child["tool_name"] or "unknown"
+                by_tool[tool] = by_tool.get(tool, 0) + child["cost_tokens"]
+
+        # Convert to USD (approximation: 1M tokens ~ $3 for input, $6 for output)
+        # Average: ~$4.50 per 1M tokens
+        total_cost_usd = total_cost * 0.0000045
+
+        return {
+            "delegations": delegations,
+            "total_cost_tokens": total_cost,
+            "total_cost_usd": total_cost_usd,
+            "total_delegations": len(delegations),
+            "avg_cost_per_delegation": (
+                total_cost / len(delegations) if delegations else 0
+            ),
+            "by_subagent_type": by_subagent,
+            "by_tool_type": by_tool,
+        }
+
+    def get_cost_by_subagent_type(self) -> dict[str, int]:
+        """
+        Group delegation costs by subagent type.
+
+        Returns:
+            Dictionary mapping subagent_type to total tokens spent
+        """
+        data = self.get_task_delegations_with_costs()
+        result = data.get("by_subagent_type", {})
+        if isinstance(result, dict):
+            return result
+        return {}
+
+    def get_cost_by_tool_type(self) -> dict[str, int]:
+        """
+        Show which tools cost most across all delegations.
+
+        Returns:
+            Dictionary mapping tool_name to total tokens spent
+        """
+        data = self.get_task_delegations_with_costs()
+        result = data.get("by_tool_type", {})
+        if isinstance(result, dict):
+            return result
+        return {}
+
+    def get_roi_stats(self) -> ROIStats:
+        """
+        Calculate ROI statistics comparing delegation vs direct execution.
+
+        Assumptions:
+        - Direct execution: Tokens spent directly on main agent
+        - Delegated execution: Tokens in child subagents (already counted)
+        - Savings: Context preservation + parallelization benefits
+        - Parallelization factor: 1.2-1.5x (subagents can work more efficiently)
+        - Context preservation: ~30% token savings from better focus
+
+        Returns:
+            ROIStats with cost and savings analysis
+        """
+        data = self.get_task_delegations_with_costs()
+
+        total_delegation_cost = data["total_cost_tokens"]
+        total_delegations = data["total_delegations"]
+
+        # Estimate direct execution cost
+        # Assumption: direct execution would cost 2.5x due to context overhead
+        estimated_direct_cost = int(total_delegation_cost * 2.5)
+
+        # Estimate savings
+        # Parallelization benefit: 1.2x efficiency
+        # Context preservation: 30% savings
+        parallelization_factor = 1.2
+        context_benefit = 0.30
+
+        estimated_savings = int(
+            estimated_direct_cost
+            - (total_delegation_cost * parallelization_factor * (1.0 - context_benefit))
+        )
+
+        savings_percentage = (
+            (estimated_savings / estimated_direct_cost * 100)
+            if estimated_direct_cost > 0
+            else 0.0
+        )
+
+        return ROIStats(
+            total_delegation_cost=total_delegation_cost,
+            estimated_direct_cost=estimated_direct_cost,
+            estimated_savings=estimated_savings,
+            savings_percentage=savings_percentage,
+            avg_parallelization_factor=parallelization_factor,
+            context_preservation_benefit=context_benefit,
+            total_delegations=total_delegations,
+            avg_cost_per_delegation=(
+                total_delegation_cost / total_delegations
+                if total_delegations > 0
+                else 0.0
+            ),
+        )
+
+    def get_top_delegations(self, limit: int = 10) -> list[TaskDelegation]:
+        """
+        Get the most expensive Task delegations.
+
+        Args:
+            limit: Number of delegations to return (default: 10)
+
+        Returns:
+            List of TaskDelegation sorted by cost (descending)
+        """
+        data = self.get_task_delegations_with_costs()
+        delegations = data["delegations"]
+
+        # Sort by cost descending
+        sorted_delegations = sorted(
+            delegations, key=lambda d: d.total_cost_tokens, reverse=True
+        )
+
+        return sorted_delegations[:limit]
+
+    def get_cost_breakdown(self) -> CostBreakdown:
+        """
+        Get comprehensive cost breakdown.
+
+        Returns:
+            CostBreakdown with by_subagent and by_tool analysis
+        """
+        data = self.get_task_delegations_with_costs()
+
+        return CostBreakdown(
+            by_subagent=data["by_subagent_type"],
+            by_tool=data["by_tool_type"],
+            total_cost_tokens=data["total_cost_tokens"],
+            total_delegations=data["total_delegations"],
+            avg_cost_per_delegation=data["avg_cost_per_delegation"],
+        )

htmlgraph/analytics/cost_reporter.py

@@ -0,0 +1,675 @@
+"""
+CostReporter for OTEL ROI Analysis - Phase 1.
+
+Generates interactive HTML dashboards showing cost analysis of Task delegations.
+Creates visualizations of delegation costs, ROI, and optimization recommendations.
+
+Features:
+- Top 10 most expensive Task delegations
+- Cost breakdown by subagent type and tool type
+- ROI analysis comparing delegation vs direct execution
+- Interactive charts using Chart.js
+- Dark theme matching HtmlGraph visual style
+
+Usage:
+    from htmlgraph.analytics.cost_analyzer import CostAnalyzer
+    from htmlgraph.analytics.cost_reporter import CostReporter
+
+    analyzer = CostAnalyzer()
+    reporter = CostReporter()
+    html = reporter.generate_dashboard(analyzer)
+    reporter.save_dashboard(html, "cost-analysis.html")
+"""
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from htmlgraph.analytics.cost_analyzer import CostAnalyzer
+
+
+class CostReporter:
+    """Generate interactive HTML dashboards from cost analysis data."""
+
+    THEME = {
+        "bg_primary": "#1a1a2e",
+        "bg_secondary": "#16213e",
+        "text_primary": "#e0e0e0",
+        "text_secondary": "#b0b0b0",
+        "accent_primary": "#0f3460",
+        "accent_secondary": "#e94560",
+        "success": "#4caf50",
+        "warning": "#ff9800",
+        "error": "#f44336",
+    }
+
+    def __init__(self) -> None:
+        """Initialize CostReporter."""
+        self.generated_at = datetime.now()
+
+    def generate_dashboard(self, analyzer: CostAnalyzer) -> str:
+        """
+        Generate complete interactive HTML dashboard.
+
+        Args:
+            analyzer: CostAnalyzer instance with cost data
+
+        Returns:
+            Complete HTML document as string
+        """
+        # Gather data
+        cost_breakdown = analyzer.get_cost_breakdown()
+        roi_stats = analyzer.get_roi_stats()
+        top_delegations = analyzer.get_top_delegations(10)
+        all_delegations = analyzer.get_task_delegations_with_costs()
+
+        # Build dashboard components
+        html_parts = [
+            self._html_header(),
+            self._html_styles(),
+            self._html_body_open(),
+            self._html_header_section(roi_stats),
+            self._html_summary_cards(roi_stats, cost_breakdown),
+            self._html_charts_section(cost_breakdown, all_delegations),
+            self._html_top_delegations_table(top_delegations),
+            self._html_insights_section(roi_stats, cost_breakdown),
+            self._html_footer_section(),
+            self._html_body_close(),
+            self._html_scripts(cost_breakdown, all_delegations),
+        ]
+
+        return "\n".join(html_parts)
+
+    def save_dashboard(self, html: str, path: str | Path) -> None:
+        """
+        Save HTML dashboard to file.
+
+        Args:
+            html: HTML content to save
+            path: File path to save to
+        """
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(html, encoding="utf-8")
+
+    # ===== HTML Generation Methods =====
+
+    def _html_header(self) -> str:
+        """Generate HTML document header."""
+        return """<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Cost Attribution Dashboard - HtmlGraph OTEL ROI Analysis</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.js"></script>
+</head>"""
+
+    def _html_styles(self) -> str:
+        """Generate CSS styles."""
+        return f"""<style>
+* {{
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}}
+
+body {{
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    background-color: {self.THEME["bg_primary"]};
+    color: {self.THEME["text_primary"]};
+    line-height: 1.6;
+}}
+
+a {{
+    color: {self.THEME["accent_secondary"]};
+    text-decoration: none;
+}}
+
+a:hover {{
+    text-decoration: underline;
+}}
+
+.container {{
+    max-width: 1400px;
+    margin: 0 auto;
+    padding: 20px;
+}}
+
+.header {{
+    border-bottom: 2px solid {self.THEME["accent_primary"]};
+    padding-bottom: 20px;
+    margin-bottom: 30px;
+}}
+
+.header h1 {{
+    font-size: 2.5em;
+    margin-bottom: 10px;
+    color: {self.THEME["text_primary"]};
+}}
+
+.header .subtitle {{
+    color: {self.THEME["text_secondary"]};
+    font-size: 0.95em;
+}}
+
+.header-meta {{
+    margin-top: 15px;
+    display: flex;
+    gap: 20px;
+    flex-wrap: wrap;
+    font-size: 0.9em;
+    color: {self.THEME["text_secondary"]};
+}}
+
+.cards {{
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+    gap: 20px;
+    margin-bottom: 40px;
+}}
+
+.card {{
+    background-color: {self.THEME["bg_secondary"]};
+    border: 1px solid {self.THEME["accent_primary"]};
+    border-radius: 8px;
+    padding: 25px;
+    transition: all 0.3s ease;
+}}
+
+.card:hover {{
+    border-color: {self.THEME["accent_secondary"]};
+    transform: translateY(-5px);
+    box-shadow: 0 10px 30px rgba(233, 69, 96, 0.2);
+}}
+
+.card-label {{
+    color: {self.THEME["text_secondary"]};
+    font-size: 0.85em;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    margin-bottom: 10px;
+}}
+
+.card-value {{
+    font-size: 2.5em;
+    font-weight: bold;
+    margin-bottom: 8px;
+    color: {self.THEME["text_primary"]};
+}}
+
+.card-unit {{
+    color: {self.THEME["text_secondary"]};
+    font-size: 0.9em;
+    font-weight: normal;
+}}
+
+.card-meta {{
+    color: {self.THEME["text_secondary"]};
+    font-size: 0.85em;
+    margin-top: 12px;
+    padding-top: 12px;
+    border-top: 1px solid {self.THEME["accent_primary"]};
+}}
+
+.status-good {{
+    color: {self.THEME["success"]};
+}}
+
+.status-warning {{
+    color: {self.THEME["warning"]};
+}}
+
+.status-error {{
+    color: {self.THEME["error"]};
+}}
+
+.charts {{
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(400px, 1fr));
+    gap: 30px;
+    margin-bottom: 40px;
+}}
+
+.chart-container {{
+    background-color: {self.THEME["bg_secondary"]};
+    border: 1px solid {self.THEME["accent_primary"]};
+    border-radius: 8px;
+    padding: 20px;
+}}
+
+.chart-title {{
+    font-size: 1.3em;
+    font-weight: 600;
+    margin-bottom: 20px;
+    color: {self.THEME["text_primary"]};
+}}
+
+.chart-canvas {{
+    max-height: 400px;
+}}
+
+.table-section {{
+    margin-bottom: 40px;
+}}
+
+.table-section h2 {{
+    font-size: 1.5em;
+    margin-bottom: 20px;
+    color: {self.THEME["text_primary"]};
+}}
+
+.table-wrapper {{
+    overflow-x: auto;
+    background-color: {self.THEME["bg_secondary"]};
+    border: 1px solid {self.THEME["accent_primary"]};
+    border-radius: 8px;
+}}
+
+table {{
+    width: 100%;
+    border-collapse: collapse;
+}}
+
+th {{
+    background-color: {self.THEME["accent_primary"]};
+    padding: 15px;
+    text-align: left;
+    font-weight: 600;
+    color: {self.THEME["text_primary"]};
+    border-bottom: 2px solid {self.THEME["accent_secondary"]};
+}}
+
+td {{
+    padding: 12px 15px;
+    border-bottom: 1px solid {self.THEME["accent_primary"]};
+    color: {self.THEME["text_primary"]};
+}}
+
+tr:hover {{
+    background-color: {self.THEME["accent_primary"]};
+}}
+
+.insights {{
+    background-color: {self.THEME["bg_secondary"]};
+    border: 1px solid {self.THEME["accent_primary"]};
+    border-radius: 8px;
+    padding: 25px;
+    margin-bottom: 40px;
+}}
+
+.insights h2 {{
+    font-size: 1.5em;
+    margin-bottom: 20px;
+    color: {self.THEME["text_primary"]};
+}}
+
+.insight {{
+    margin-bottom: 20px;
+    padding: 15px;
+    background-color: {self.THEME["bg_primary"]};
+    border-left: 4px solid {self.THEME["accent_secondary"]};
+    border-radius: 4px;
+}}
+
+.insight-title {{
+    font-weight: 600;
+    color: {self.THEME["accent_secondary"]};
+    margin-bottom: 8px;
+}}
+
+.insight-text {{
+    color: {self.THEME["text_secondary"]};
+    line-height: 1.6;
+}}
+
+.footer {{
+    text-align: center;
+    padding-top: 20px;
+    border-top: 1px solid {self.THEME["accent_primary"]};
+    color: {self.THEME["text_secondary"]};
+    font-size: 0.85em;
+}}
+
+@media (max-width: 768px) {{
+    .charts {{
+        grid-template-columns: 1fr;
+    }}
+
+    .header h1 {{
+        font-size: 1.8em;
+    }}
+
+    .card-value {{
+        font-size: 2em;
+    }}
+
+    table {{
+        font-size: 0.9em;
+    }}
+
+    th, td {{
+        padding: 10px;
+    }}
+}}
+</style>"""
+
+    def _html_body_open(self) -> str:
+        """Generate opening body tag."""
+        return "<body>"
+
+    def _html_body_close(self) -> str:
+        """Generate closing body tag."""
+        return "</body></html>"
+
+    def _html_header_section(self, roi_stats: Any) -> str:
+        """Generate dashboard header section."""
+        generated_at = self.generated_at.strftime("%Y-%m-%d %H:%M:%S")
+
+        return f"""<div class="container">
+    <div class="header">
+        <h1>Cost Attribution Dashboard</h1>
+        <p class="subtitle">OTEL ROI Analysis - Phase 1 MVP</p>
+        <div class="header-meta">
+            <span>Generated: <strong>{generated_at}</strong></span>
+            <span>Total Delegations: <strong>{roi_stats.total_delegations}</strong></span>
+            <span>Status: <strong class="status-good">✓ Active</strong></span>
+        </div>
+    </div>
+"""
+
+    def _html_summary_cards(self, roi_stats: Any, cost_breakdown: Any) -> str:
+        """Generate summary metric cards."""
+        total_cost_usd = roi_stats.total_delegation_cost * 0.0000045
+
+        return f"""<div class="cards">
+        <div class="card">
+            <div class="card-label">Total Delegation Cost</div>
+            <div class="card-value">${total_cost_usd:.2f}<span class="card-unit"> USD</span></div>
+            <div class="card-meta">{roi_stats.total_delegation_cost:,} tokens</div>
+        </div>
+
+        <div class="card">
+            <div class="card-label">Estimated Direct Cost</div>
+            <div class="card-value">${roi_stats.estimated_direct_cost * 0.0000045:.2f}<span class="card-unit"> USD</span></div>
+            <div class="card-meta">{roi_stats.estimated_direct_cost:,} tokens (2.5x overhead)</div>
+        </div>
+
+        <div class="card">
+            <div class="card-label">Estimated Savings</div>
+            <div class="card-value"><span class="status-good">${roi_stats.estimated_savings * 0.0000045:.2f}</span></div>
+            <div class="card-meta"><span class="status-good">{roi_stats.savings_percentage:.0f}% reduction</span></div>
+        </div>
+
+        <div class="card">
+            <div class="card-label">Avg Cost per Delegation</div>
+            <div class="card-value">{roi_stats.avg_cost_per_delegation:,.0f}<span class="card-unit"> tokens</span></div>
+            <div class="card-meta">Across {roi_stats.total_delegations} delegations</div>
+        </div>
+    </div>
+"""
+
+    def _html_charts_section(self, cost_breakdown: Any, all_delegations: Any) -> str:
+        """Generate charts section with visualizations."""
+        # Prepare data for charts
+        subagent_labels = list(cost_breakdown.by_subagent.keys())
+        subagent_data = list(cost_breakdown.by_subagent.values())
+
+        tool_labels = list(cost_breakdown.by_tool.keys())
+        tool_data = list(cost_breakdown.by_tool.values())
+
+        # Embed data as JSON for JavaScript
+        subagent_labels_json = json.dumps(subagent_labels)
+        subagent_data_json = json.dumps(subagent_data)
+        tool_labels_json = json.dumps(tool_labels)
+        tool_data_json = json.dumps(tool_data)
+
+        return f"""<div class="charts">
+        <div class="chart-container">
+            <div class="chart-title">Cost by Subagent Type</div>
+            <canvas id="chartBySubagent" class="chart-canvas"></canvas>
+        </div>
+
+        <div class="chart-container">
+            <div class="chart-title">Cost by Tool Type</div>
+            <canvas id="chartByTool" class="chart-canvas"></canvas>
+        </div>
+    </div>
+
+    <script>
+        window.chartData = {{
+            subagent_labels: {subagent_labels_json},
+            subagent_data: {subagent_data_json},
+            tool_labels: {tool_labels_json},
+            tool_data: {tool_data_json}
+        }};
+    </script>
+"""
+
+    def _html_top_delegations_table(self, top_delegations: list[Any]) -> str:
+        """Generate top delegations table."""
+        table_rows = ""
+
+        for i, delegation in enumerate(top_delegations, 1):
+            cost_usd = delegation.total_cost_tokens * 0.0000045
+            timestamp = delegation.timestamp.strftime("%Y-%m-%d %H:%M:%S")
+
+            table_rows += f"""        <tr>
+            <td>{i}</td>
+            <td>{timestamp}</td>
+            <td><strong>{delegation.subagent_type}</strong></td>
+            <td>{delegation.tool_count}</td>
+            <td>{delegation.total_cost_tokens:,}</td>
+            <td>${cost_usd:.2f}</td>
+            <td><code style="font-size: 0.85em; color: #b0b0b0;">{delegation.event_id[:16]}...</code></td>
+        </tr>
+"""
+
+        return f"""<div class="table-section">
+        <h2>Top 10 Most Expensive Delegations</h2>
+        <div class="table-wrapper">
+            <table>
+                <thead>
+                    <tr>
+                        <th>#</th>
+                        <th>Timestamp</th>
+                        <th>Subagent Type</th>
+                        <th>Tool Count</th>
+                        <th>Cost (tokens)</th>
+                        <th>Cost (USD)</th>
+                        <th>Event ID</th>
+                    </tr>
+                </thead>
+                <tbody>
+{table_rows}                </tbody>
+            </table>
+        </div>
+    </div>
+"""
+
+    def _html_insights_section(self, roi_stats: Any, cost_breakdown: Any) -> str:
+        """Generate insights and recommendations."""
+        insights = []
+
+        # Insight 1: ROI summary
+        if roi_stats.savings_percentage > 40:
+            insights.append(
+                (
+                    "Strong Delegation ROI",
+                    f"Your delegation strategy is effective. By properly delegating work, "
+                    f"you're achieving approximately {roi_stats.savings_percentage:.0f}% cost savings "
+                    f"compared to direct execution.",
+                )
+            )
+        else:
+            insights.append(
+                (
+                    "Delegation Opportunity",
+                    f"Current delegation strategy shows {roi_stats.savings_percentage:.0f}% potential savings. "
+                    f"Consider delegating more complex work to specialized subagents.",
+                )
+            )
+
+        # Insight 2: Most expensive subagent
+        if cost_breakdown.by_subagent:
+            top_subagent = max(cost_breakdown.by_subagent.items(), key=lambda x: x[1])
+            insights.append(
+                (
+                    f"Highest Cost Subagent: {top_subagent[0]}",
+                    f"This subagent type accounts for {top_subagent[1]:,} tokens. "
+                    f"Review the work being delegated here for optimization opportunities.",
+                )
+            )
+
+        # Insight 3: Most expensive tool
+        if cost_breakdown.by_tool:
+            top_tool = max(cost_breakdown.by_tool.items(), key=lambda x: x[1])
+            insights.append(
+                (
+                    f"Highest Cost Tool: {top_tool[0]}",
+                    f"This tool is consuming {top_tool[1]:,} tokens. "
+                    f"Consider batching operations or using more efficient approaches.",
+                )
+            )
+
+        # Insight 4: Parallelization benefit
+        insights.append(
+            (
+                "Parallelization Benefit",
+                f"Subagent delegation enables {roi_stats.avg_parallelization_factor:.1f}x efficiency gain "
+                f"through parallel execution and focused context.",
+            )
+        )
+
+        insights_html = ""
+        for title, text in insights:
+            insights_html += f"""        <div class="insight">
+            <div class="insight-title">{title}</div>
+            <div class="insight-text">{text}</div>
+        </div>
+"""
+
+        return f"""<div class="insights">
+        <h2>Insights & Recommendations</h2>
+{insights_html}    </div>
+"""
+
+    def _html_footer_section(self) -> str:
+        """Generate footer section."""
+        return """    <div class="footer">
+        <p>HtmlGraph Cost Attribution Dashboard | OTEL ROI Analysis Phase 1 | <a href="https://code.claude.com">Claude Code</a></p>
+    </div>
+</div>"""
+
+    def _html_scripts(self, cost_breakdown: Any, all_delegations: Any) -> str:
+        """Generate JavaScript for interactive charts."""
+        return """<script>
+document.addEventListener('DOMContentLoaded', function() {
+    const data = window.chartData || {
+        subagent_labels: [],
+        subagent_data: [],
+        tool_labels: [],
+        tool_data: []
+    };
+
+    const chartOptions = {
+        responsive: true,
+        maintainAspectRatio: true,
+        plugins: {
+            legend: {
+                labels: {
+                    color: '#e0e0e0',
+                    font: { size: 12 }
+                }
+            },
+            tooltip: {
+                backgroundColor: 'rgba(26, 26, 46, 0.8)',
+                titleColor: '#e0e0e0',
+                bodyColor: '#b0b0b0',
+                borderColor: '#0f3460',
+                borderWidth: 1
+            }
+        },
+        scales: {
+            y: {
+                ticks: { color: '#b0b0b0' },
+                grid: { color: '#16213e' }
+            },
+            x: {
+                ticks: { color: '#b0b0b0' },
+                grid: { color: '#16213e' }
+            }
+        }
+    };
+
+    // Doughnut chart - Cost by Subagent Type
+    if (data.subagent_labels.length > 0) {
+        const ctxSubagent = document.getElementById('chartBySubagent');
+        if (ctxSubagent) {
+            new Chart(ctxSubagent, {
+                type: 'doughnut',
+                data: {
+                    labels: data.subagent_labels,
+                    datasets: [{
+                        label: 'Cost (tokens)',
+                        data: data.subagent_data,
+                        backgroundColor: [
+                            '#e94560',
+                            '#ff9800',
+                            '#ff6f00',
+                            '#d84315',
+                            '#c62828',
+                            '#0f3460'
+                        ],
+                        borderColor: '#1a1a2e',
+                        borderWidth: 2
+                    }]
+                },
+                options: {
+                    ...chartOptions,
+                    plugins: {
+                        ...chartOptions.plugins,
+                        legend: {
+                            ...chartOptions.plugins.legend,
+                            position: 'bottom'
+                        }
+                    }
+                }
+            });
+        }
+    }
+
+    // Bar chart - Cost by Tool
+    if (data.tool_labels.length > 0) {
+        const ctxTool = document.getElementById('chartByTool');
+        if (ctxTool) {
+            new Chart(ctxTool, {
+                type: 'bar',
+                data: {
+                    labels: data.tool_labels,
+                    datasets: [{
+                        label: 'Cost (tokens)',
+                        data: data.tool_data,
+                        backgroundColor: '#0f3460',
+                        borderColor: '#e94560',
+                        borderWidth: 2,
+                        borderRadius: 4
+                    }]
+                },
+                options: {
+                    ...chartOptions,
+                    indexAxis: 'y',
+                    plugins: {
+                        ...chartOptions.plugins,
+                        legend: {
+                            ...chartOptions.plugins.legend,
+                            display: true
+                        }
+                    }
+                }
+            });
+        }
+    }
+});
+</script>"""

htmlgraph/cli/.htmlgraph/.session-warning-state.json

@@ -2,5 +2,5 @@
   "dismissed_at": null,
   "dismissed_by": null,
   "session_id": null,
-  "show_count": 104
+  "show_count": 471
 }

htmlgraph/cli/analytics.py

@@ -96,6 +96,25 @@ def _register_cigs_commands(subparsers: _SubParsersAction) -> None:
     cost_dashboard.add_argument("--output", help="Custom output path")
     cost_dashboard.set_defaults(func=CostDashboardCommand.from_args)
 
+    # cigs roi-analysis (Phase 1 OTEL ROI)
+    roi_analysis = cigs_subparsers.add_parser(
+        "roi-analysis", help="OTEL ROI analysis - cost attribution of Task delegations"
+    )
+    roi_analysis.add_argument(
+        "--graph-dir", "-g", default=DEFAULT_GRAPH_DIR, help="Graph directory"
+    )
+    roi_analysis.add_argument(
+        "--save", action="store_true", help="Save to .htmlgraph/cost-analysis.html"
+    )
+    roi_analysis.add_argument(
+        "--open", action="store_true", help="Open in browser after generation"
+    )
+    roi_analysis.add_argument(
+        "--json", action="store_true", help="Output JSON instead of HTML"
+    )
+    roi_analysis.add_argument("--output", help="Custom output path")
+    # roi_analysis.set_defaults(func=OTELROIAnalysisCommand.from_args)  # TODO: Implement OTELROIAnalysisCommand
+
     # cigs status
     cigs_status = cigs_subparsers.add_parser("status", help="Show CIGS status")
     cigs_status.add_argument(

htmlgraph/hooks/posttooluse.py

@@ -49,6 +49,48 @@ async def run_event_tracking(
     Returns:
         Event tracking response: {"continue": True, "hookSpecificOutput": {...}}
     """
+    # ============ DEBUG: Log Task() responses ============
+    import json
+
+    tool_name = hook_input.get("name", "") or hook_input.get("tool_name", "")
+    if tool_name == "Task":
+        tool_response = hook_input.get("tool_response", {})
+
+        print("\n" + "=" * 60, file=sys.stderr)
+        print("DEBUG: Task() PostToolUse Hook Input", file=sys.stderr)
+        print("=" * 60, file=sys.stderr)
+
+        print(f"\nTool Name: {tool_name}", file=sys.stderr)
+        print(f"Hook Type: {hook_type}", file=sys.stderr)
+
+        if isinstance(tool_response, dict):
+            print("\nTool Response Type: dict", file=sys.stderr)
+            print(f"Tool Response Keys: {list(tool_response.keys())}", file=sys.stderr)
+
+            # Check for task_id field
+            if "task_id" in tool_response:
+                task_id = tool_response.get("task_id")
+                print(f"\n✅ FOUND task_id: {task_id}", file=sys.stderr)
+            else:
+                print("\n❌ task_id NOT FOUND in response", file=sys.stderr)
+
+            # Print full response for inspection
+            print("\nFull Tool Response:", file=sys.stderr)
+            try:
+                response_str = json.dumps(tool_response, indent=2, default=str)
+                print(response_str, file=sys.stderr)
+            except Exception as e:
+                print(f"Could not serialize response: {e}", file=sys.stderr)
+                print(f"Raw response: {tool_response}", file=sys.stderr)
+        else:
+            print(
+                f"\nTool Response Type: {type(tool_response).__name__}", file=sys.stderr
+            )
+            print(f"Tool Response Value: {tool_response}", file=sys.stderr)
+
+        print("\n" + "=" * 60 + "\n", file=sys.stderr)
+    # ============ END DEBUG ============
+
     try:
         loop = asyncio.get_event_loop()
 

{htmlgraph-0.26.12.dist-info → htmlgraph-0.26.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlgraph
-Version: 0.26.12
+Version: 0.26.14
 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.26.12.dist-info → htmlgraph-0.26.14.dist-info}/RECORD

@@ -1,4 +1,4 @@
-htmlgraph/__init__.py,sha256=VIeTSZpmbiqRu9ld4dQs_71PfKYQvlaJ90SeGVW4ybk,5718
+htmlgraph/__init__.py,sha256=aFjqr9RP4Lzx2kZCoH8PRKdbaMd4an9tAnvEG9xLapo,5718
 htmlgraph/agent_detection.py,sha256=wEmrDv4hssPX2OkEnJZBHPbalxcaloiJF_hOOow_5WE,3511
 htmlgraph/agent_registry.py,sha256=Usa_35by7p5gtpvHO7K3AcGimnorw-FzgPVa3cWTQ58,9448
 htmlgraph/agents.py,sha256=Yvu6x1nOfrW2WhRTAHiCuSpvqoVJXx1Mkzd59kwEczw,33466
@@ -69,8 +69,10 @@ htmlgraph/work_type_utils.py,sha256=exA3FnuSmVMMMSBhPYDW-Bq5jGaTDjX7jkckCvnVZ_s,
 htmlgraph/.htmlgraph/.session-warning-state.json,sha256=X7xLzJc57pWuOLyg5iN7D9hp0CvaYY6UWBq8ImcIBmg,92
 htmlgraph/.htmlgraph/agents.json,sha256=dKaiSsd1L7iaQa1_s9lCpNEZH-1S_n0CfzmCHFoWyvc,1391
 htmlgraph/.htmlgraph/htmlgraph.db,sha256=gto2pndMBw97gljvwPywDlTUzYdoa_FnNJs3AsS9_SI,262144
-htmlgraph/analytics/__init__.py,sha256=G_DvCaiAeYVfMWFri1GOfLNF7PtAhitKa2V9TXHtsds,409
+htmlgraph/analytics/__init__.py,sha256=jVcxE-9eGupT8IC5YMh8SqPc_w4k7GpPK0WfXj6SE4M,607
 htmlgraph/analytics/cli.py,sha256=aSnxkvNdrdukytqSirpFtcuiNRbg3Dt-hSpUsDPF9jo,14771
+htmlgraph/analytics/cost_analyzer.py,sha256=tNVLRKesS6thCr89Xw6Bjz5K6Drn-pagiIjiF16hgQo,12854
+htmlgraph/analytics/cost_reporter.py,sha256=_KumnYUYTr3yEHwBGGgjXSHR5IGPLDqjfuZHpfbeNi8,19917
 htmlgraph/analytics/cross_session.py,sha256=BmTNqyt1qYjKbq5sXDYGxp85G2XB2aHkIvdqRgSIQBw,20494
 htmlgraph/analytics/dependency.py,sha256=7Qc5xe0b1QE_P6-l4Z0WtstEmEXc4ZGNbyIEBMoABys,25757
 htmlgraph/analytics/work_type.py,sha256=SrZvY_RVq70uvzl3Ky7I3LHgOMduW_0vdSsk5yUZRG4,19293
@@ -123,15 +125,15 @@ htmlgraph/cigs/reporter.py,sha256=DgfHjD_ufP6a9Fmfm_-Ro50bDCQrNC6BZYl3dYNl86o,24
 htmlgraph/cigs/tracker.py,sha256=OcyXY7tGxbRCtlLX8Pg2bVtCtzPJtvh1VOtt4jbL9SI,10502
 htmlgraph/cli/__init__.py,sha256=0r1gr-uzhMS9_wz88IjGf5ma4bDK-zTzUX6p8Wq5n2U,1031
 htmlgraph/cli/__main__.py,sha256=lkTNsdh3X-vgKz_jzQe0IQmZY5PWlMjGBuaQR-gsqf8,137
-htmlgraph/cli/analytics.py,sha256=0Fat2vgVvqv5GZLuDJwX_fhb0iVkxiu2a9xXKO89Qf0,34823
+htmlgraph/cli/analytics.py,sha256=KRw40n8lq_TOJno0eM97qsMiVZpmU6R7YN0dKKI4gwQ,35654
 htmlgraph/cli/base.py,sha256=OjybqWTQfLtQD5wBbz8IDDkE-2N6jpcXYdOq5BXza2I,20248
 htmlgraph/cli/constants.py,sha256=S7hAih2Ka64c0sWqOdq7W762VRoBHri8w8XDDWqHCkE,7088
 htmlgraph/cli/core.py,sha256=JhRL1iZhN3x4IeeVQkK4GnfAV7JQm5JDU6hG473GBOs,28878
 htmlgraph/cli/main.py,sha256=rSSSErlmFHrREbAydtytj3up8M_dQ9jFgYL1OmrSQas,4108
 htmlgraph/cli/models.py,sha256=7dEAwsroH2J_84Bq6i9Q0RLJsKQ9rNbX_daOfHdrb78,16033
-htmlgraph/cli/.htmlgraph/.session-warning-state.json,sha256=rMkFdGlJQLQI41LP_xOh22bcoZXZAWjMBZHPDzEs7jg,93
+htmlgraph/cli/.htmlgraph/.session-warning-state.json,sha256=jKw9n3GDSPzcHwZZnRoW7eOJEbQPQ3FKpvo3kMY7lHw,93
 htmlgraph/cli/.htmlgraph/agents.json,sha256=hVmmvoL4CDTIrhxH7VaM-jSDCj8kszWsUFY_LHae9DQ,1391
-htmlgraph/cli/.htmlgraph/htmlgraph.db,sha256=Q8lPXN1T4By7XDuGWuig_MX6CQ-6IPl5XFjEx2EZxwg,372736
+htmlgraph/cli/.htmlgraph/htmlgraph.db,sha256=Ipk3K21EQyTT5hkimtL1dBiwHve-3zdpS4yP1wMMU-4,1343488
 htmlgraph/cli/templates/__init__.py,sha256=7eh8oC8rce689HGuuYqJEMCElJCtg084xOMHZti2XL8,37
 htmlgraph/cli/templates/cost_dashboard.py,sha256=2FRaujRUYEDfA18c0QFju28yidfaVnMFH4pdcBaQ7Ao,11313
 htmlgraph/cli/work/__init__.py,sha256=yFK8G85F-Z9df-3LBM-3NbjCgidtLEVhkYGO1uf4QuI,4570
@@ -201,7 +203,7 @@ htmlgraph/hooks/post-commit.sh,sha256=if65jNGZnEWsZPq_iYDNYunrZ1cmjPUEUbh6_4vfpO
 htmlgraph/hooks/post-merge.sh,sha256=gq-EeFLhDUVp-J2jyWMBVFcB0pdmH54Wu1SW_Gn-s2I,541
 htmlgraph/hooks/post_tool_use_failure.py,sha256=DHkJtuAOg5KSLfFZ1O-kePwaqmtNkbGQSEn4NplzvD8,8381
 htmlgraph/hooks/post_tool_use_handler.py,sha256=e0L8X4sU2H167HH96CgV6iYojd02AI9uyF8m4A1a-kU,8345
-htmlgraph/hooks/posttooluse.py,sha256=3usICpqlIdLKsijYY61BP2QezsB45MZ6evwFSobC9Yo,12822
+htmlgraph/hooks/posttooluse.py,sha256=HOxW9lgJCnRLJRsdB7PFfAJkPWv-NiLjkF4wcBnjVUE,14606
 htmlgraph/hooks/pre-commit.sh,sha256=gTpbnHIBFxpAl7-REhXoS0NI4Pmlqo9pQEMEngTAU_A,3865
 htmlgraph/hooks/pre-push.sh,sha256=rNnkG8YmDtyk7OuJHOcbOYQR3MYFneaG6_w2X-Hl8Hs,660
 htmlgraph/hooks/pretooluse.py,sha256=5mW-hMmJZlFvahDfA9yCfPrtaN6yAlWTOchirE-zZdU,27327
@@ -250,12 +252,12 @@ htmlgraph/templates/AGENTS.md.template,sha256=f96h7V6ygwj-v-fanVI48eYMxR6t_se4be
 htmlgraph/templates/CLAUDE.md.template,sha256=h1kG2hTX2XYig2KszsHBfzrwa_4Cfcq2Pj4SwqzeDlM,1984
 htmlgraph/templates/GEMINI.md.template,sha256=gAGzE53Avki87BM_otqy5HdcYCoLsHgqaKjVzNzPMX8,1622
 htmlgraph/templates/orchestration-view.html,sha256=DlS7LlcjH0oO_KYILjuF1X42t8QhKLH4F85rkO54alY,10472
-htmlgraph-0.26.12.data/data/htmlgraph/dashboard.html,sha256=MUT6SaYnazoyDcvHz5hN1omYswyIoUfeoZLf2M_iblo,251268
-htmlgraph-0.26.12.data/data/htmlgraph/styles.css,sha256=oDUSC8jG-V-hKojOBO9J88hxAeY2wJrBYTq0uCwX_Y4,7135
-htmlgraph-0.26.12.data/data/htmlgraph/templates/AGENTS.md.template,sha256=f96h7V6ygwj-v-fanVI48eYMxR6t_se4bet1H4ZsDpI,7642
-htmlgraph-0.26.12.data/data/htmlgraph/templates/CLAUDE.md.template,sha256=h1kG2hTX2XYig2KszsHBfzrwa_4Cfcq2Pj4SwqzeDlM,1984
-htmlgraph-0.26.12.data/data/htmlgraph/templates/GEMINI.md.template,sha256=gAGzE53Avki87BM_otqy5HdcYCoLsHgqaKjVzNzPMX8,1622
-htmlgraph-0.26.12.dist-info/METADATA,sha256=R1tGyLhAmPDlODF8OXT3coPYDDxXi_REg05NOpNeEQA,10237
-htmlgraph-0.26.12.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-htmlgraph-0.26.12.dist-info/entry_points.txt,sha256=Wmdo5cx8pt6NoMsssVE2mZH1CZLSUsrg_3iSWatiyn0,103
-htmlgraph-0.26.12.dist-info/RECORD,,
+htmlgraph-0.26.14.data/data/htmlgraph/dashboard.html,sha256=MUT6SaYnazoyDcvHz5hN1omYswyIoUfeoZLf2M_iblo,251268
+htmlgraph-0.26.14.data/data/htmlgraph/styles.css,sha256=oDUSC8jG-V-hKojOBO9J88hxAeY2wJrBYTq0uCwX_Y4,7135
+htmlgraph-0.26.14.data/data/htmlgraph/templates/AGENTS.md.template,sha256=f96h7V6ygwj-v-fanVI48eYMxR6t_se4bet1H4ZsDpI,7642
+htmlgraph-0.26.14.data/data/htmlgraph/templates/CLAUDE.md.template,sha256=h1kG2hTX2XYig2KszsHBfzrwa_4Cfcq2Pj4SwqzeDlM,1984
+htmlgraph-0.26.14.data/data/htmlgraph/templates/GEMINI.md.template,sha256=gAGzE53Avki87BM_otqy5HdcYCoLsHgqaKjVzNzPMX8,1622
+htmlgraph-0.26.14.dist-info/METADATA,sha256=BOzq9w86UFDhZgsaZCIMYf8Cp4nqHf8_rWEC_-7EOF4,10237
+htmlgraph-0.26.14.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+htmlgraph-0.26.14.dist-info/entry_points.txt,sha256=Wmdo5cx8pt6NoMsssVE2mZH1CZLSUsrg_3iSWatiyn0,103
+htmlgraph-0.26.14.dist-info/RECORD,,