htmlgraph 0.20.9__py3-none-any.whl → 0.21.0__py3-none-any.whl

htmlgraph/learning.py

@@ -150,68 +150,86 @@ class LearningPersistence:
         return health
 
     def persist_patterns(self, min_count: int = 2) -> list[str]:
-        """Detect and persist workflow patterns from sessions.
+        """Detect and persist workflow patterns IN SESSIONS (not as separate files).
+
+        This refactored version stores patterns inline within session HTML files
+        to avoid creating 2,890+ individual pattern files.
 
         Args:
             min_count: Minimum occurrences to persist a pattern
 
         Returns:
-            List of persisted pattern IDs
+            List of session IDs that had patterns updated
         """
-        # Collect tool sequences from all sessions
-        # Use session_manager to get full Session objects with activity_log
-        sequences: list[tuple[Any, ...]] = []
+        # Collect tool sequences per session (not globally)
+        session_ids_updated: list[str] = []
+
         for session in self.sdk.session_manager.session_converter.load_all():
-            if session.activity_log:
-                tools = [
-                    a.tool if not isinstance(a, dict) else a.get("tool", "")
-                    for a in session.activity_log
-                ]
-                # Extract 3-tool sequences
-                for i in range(len(tools) - 2):
-                    seq = tools[i : i + 3]
-                    if all(seq):  # No empty tools
-                        sequences.append(tuple(seq))
-
-        # Count sequences
-        seq_counts = Counter(sequences)
-
-        # Persist patterns with min_count
-        pattern_ids: list[str | Any] = []
-        for seq, count in seq_counts.items():  # type: ignore[assignment]
-            if count >= min_count:
-                # Check if pattern already exists
-                existing = self.sdk.patterns.find_by_sequence(list(seq))
-                if existing:
-                    # Update count - use properties dict for updates
-                    pattern = existing[0]
-                    pattern.properties["detection_count"] = count
-                    pattern.properties["last_detected"] = datetime.now().isoformat()
-                    self.sdk.patterns.update(pattern)
-                    pattern_ids.append(pattern.id)
-                else:
-                    # Create new pattern using builder methods
-                    pattern_type = self._classify_pattern(list(seq))
-                    now = datetime.now()
-                    pattern = (
-                        self.sdk.patterns.create(f"Pattern: {' -> '.join(seq)}")
-                        .set_sequence(list(seq))
-                        .set_pattern_type(pattern_type)
-                        .set_detection_count(count)
-                        .set_first_detected(now)
-                        .set_last_detected(now)
-                        .save()
+            if not session.activity_log:
+                continue
+
+            # Extract 3-tool sequences from this session
+            tools = [
+                a.tool if not isinstance(a, dict) else a.get("tool", "")
+                for a in session.activity_log
+            ]
+
+            # Count sequences in this session
+            sequences: list[tuple[Any, ...]] = []
+            for i in range(len(tools) - 2):
+                seq = tools[i : i + 3]
+                if all(seq):  # No empty tools
+                    sequences.append(tuple(seq))
+
+            seq_counts = Counter(sequences)
+
+            # Update session's detected_patterns
+            patterns_updated = False
+            for seq, count in seq_counts.items():  # type: ignore[assignment]
+                if count >= min_count:
+                    # Check if pattern already exists in this session
+                    existing = next(
+                        (
+                            p
+                            for p in session.detected_patterns
+                            if p.get("sequence") == list(seq)
+                        ),
+                        None,
                     )
-                    pattern_ids.append(pattern.id)
+
+                    if existing:
+                        # Update existing pattern
+                        existing["detection_count"] = count
+                        existing["last_detected"] = datetime.now().isoformat()
+                        patterns_updated = True
+                    else:
+                        # Add new pattern to session
+                        pattern_type = self._classify_pattern(list(seq))
+                        now = datetime.now()
+                        session.detected_patterns.append(
+                            {
+                                "sequence": list(seq),
+                                "pattern_type": pattern_type,
+                                "detection_count": count,
+                                "first_detected": now.isoformat(),
+                                "last_detected": now.isoformat(),
+                            }
+                        )
+                        patterns_updated = True
+
+            # Save updated session if patterns were modified
+            if patterns_updated:
+                self.sdk.session_manager.session_converter.save(session)
+                session_ids_updated.append(session.id)
 
         # Also persist parallel patterns
-        parallel_pattern_ids = self.persist_parallel_patterns(min_count=min_count)
-        pattern_ids.extend(parallel_pattern_ids)
+        parallel_session_ids = self.persist_parallel_patterns(min_count=min_count)
+        session_ids_updated.extend(parallel_session_ids)
 
-        return pattern_ids
+        return session_ids_updated
 
     def persist_parallel_patterns(self, min_count: int = 2) -> list[str]:
-        """Detect and persist parallel execution patterns from sessions.
+        """Detect and persist parallel execution patterns IN SESSIONS.
 
         Identifies when multiple tools are invoked in parallel (same parent_activity_id).
         This is especially useful for detecting orchestrator patterns like parallel Task delegation.
@@ -220,12 +238,11 @@ class LearningPersistence:
             min_count: Minimum occurrences to persist a pattern
 
         Returns:
-            List of persisted pattern IDs
+            List of session IDs that had parallel patterns updated
         """
         from collections import defaultdict
 
-        # Collect parallel execution groups from all sessions
-        parallel_patterns: list[tuple[str, ...]] = []
+        session_ids_updated: list[str] = []
 
         for session in self.sdk.session_manager.session_converter.load_all():
             if not session.activity_log:
@@ -242,12 +259,12 @@ class LearningPersistence:
                 if parent_id:  # Only track activities with a parent
                     parent_groups[parent_id].append(activity)
 
-            # Detect parallel patterns (2+ activities with same parent)
+            # Collect parallel patterns for this session
+            parallel_patterns: list[tuple[str, ...]] = []
             for parent_id, activities in parent_groups.items():
                 if len(activities) < 2:
                     continue
 
-                # Check if activities overlap in time (parallel execution)
                 # Sort by timestamp
                 sorted_activities = sorted(
                     activities,
@@ -268,50 +285,57 @@ class LearningPersistence:
                 if all(tools):
                     parallel_patterns.append(tools)
 
-        # Count parallel patterns
-        pattern_counts = Counter(parallel_patterns)
-
-        # Persist patterns with min_count
-        pattern_ids: list[str | Any] = []
-        for tools, count in pattern_counts.items():
-            if count >= min_count:
-                # Create a pattern name that indicates parallelism
-                tool_names = list(tools)
-                pattern_name = f"Parallel[{len(tools)}]: {' || '.join(tools)}"
-
-                # Check if pattern already exists
-                existing = self.sdk.patterns.find_by_sequence(tool_names)
-                if existing:
-                    # Update existing pattern
-                    pattern = existing[0]
-                    pattern.properties = pattern.properties or {}
-                    pattern.properties["detection_count"] = count
-                    pattern.properties["last_detected"] = datetime.now().isoformat()
-                    pattern.properties["parallel_count"] = len(tools)
-                    pattern.properties["is_parallel"] = True
-                    self.sdk.patterns.update(pattern)
-                    pattern_ids.append(pattern.id)
-                else:
-                    # Create new parallel pattern
-                    pattern_type = self._classify_pattern(tool_names, is_parallel=True)
-                    now = datetime.now()
-                    pattern = (
-                        self.sdk.patterns.create(pattern_name)
-                        .set_sequence(tool_names)
-                        .set_pattern_type(pattern_type)
-                        .set_detection_count(count)
-                        .set_first_detected(now)
-                        .set_last_detected(now)
-                        .save()
+            # Count parallel patterns in this session
+            pattern_counts = Counter(parallel_patterns)
+
+            # Update session's detected_patterns with parallel patterns
+            patterns_updated = False
+            for tools, count in pattern_counts.items():
+                if count >= min_count:
+                    tool_names = list(tools)
+
+                    # Check if pattern already exists in this session
+                    # Parallel patterns have special naming: "Parallel[N]: tool1 || tool2"
+                    existing = next(
+                        (
+                            p
+                            for p in session.detected_patterns
+                            if p.get("sequence") == tool_names
+                            and p.get("is_parallel", False)
+                        ),
+                        None,
                     )
-                    # Mark as parallel in properties
-                    pattern.properties = pattern.properties or {}
-                    pattern.properties["parallel_count"] = len(tools)
-                    pattern.properties["is_parallel"] = True
-                    self.sdk.patterns.update(pattern)
-                    pattern_ids.append(pattern.id)
-
-        return pattern_ids
+
+                    if existing:
+                        # Update existing parallel pattern
+                        existing["detection_count"] = count
+                        existing["last_detected"] = datetime.now().isoformat()
+                        patterns_updated = True
+                    else:
+                        # Add new parallel pattern to session
+                        pattern_type = self._classify_pattern(
+                            tool_names, is_parallel=True
+                        )
+                        now = datetime.now()
+                        session.detected_patterns.append(
+                            {
+                                "sequence": tool_names,
+                                "pattern_type": pattern_type,
+                                "detection_count": count,
+                                "first_detected": now.isoformat(),
+                                "last_detected": now.isoformat(),
+                                "is_parallel": True,
+                                "parallel_count": len(tools),
+                            }
+                        )
+                        patterns_updated = True
+
+            # Save updated session if patterns were modified
+            if patterns_updated:
+                self.sdk.session_manager.session_converter.save(session)
+                session_ids_updated.append(session.id)
+
+        return session_ids_updated
 
     def _classify_pattern(self, sequence: list[str], is_parallel: bool = False) -> str:
         """Classify a pattern as optimal, anti-pattern, or neutral.

htmlgraph/models.py

@@ -937,6 +937,21 @@ class Session(BaseModel):
     transcript_synced_at: datetime | None = None  # Last sync timestamp
     transcript_git_branch: str | None = None  # Git branch from transcript
 
+    # Pattern detection (inline storage to avoid file bloat)
+    detected_patterns: list[dict[str, Any]] = Field(default_factory=list)
+    """
+    Patterns detected during this session.
+
+    Format:
+    {
+        "sequence": ["Bash", "Read", "Edit"],
+        "pattern_type": "neutral",  # or "optimal", "anti_pattern"
+        "detection_count": 3,
+        "first_detected": "2026-01-02T10:00:00",
+        "last_detected": "2026-01-02T10:30:00"
+    }
+    """
+
     def add_activity(self, entry: ActivityEntry) -> None:
         """Add an activity entry to the log."""
         self.activity_log.append(entry)
@@ -1378,6 +1393,43 @@ class Session(BaseModel):
             </dl>
         </section>"""
 
+        # Build detected patterns section
+        patterns_html = ""
+        if self.detected_patterns:
+            patterns_html = f"""
+        <section data-detected-patterns>
+            <h3>Detected Patterns ({len(self.detected_patterns)})</h3>
+            <table class="patterns-table">
+                <thead>
+                    <tr>
+                        <th>Sequence</th>
+                        <th>Type</th>
+                        <th>Count</th>
+                        <th>First/Last Detected</th>
+                    </tr>
+                </thead>
+                <tbody>"""
+
+            for pattern in self.detected_patterns:
+                seq_str = " → ".join(pattern.get("sequence", []))
+                pattern_type = pattern.get("pattern_type", "neutral")
+                count = pattern.get("detection_count", 0)
+                first = pattern.get("first_detected", "")
+                last = pattern.get("last_detected", "")
+
+                patterns_html += f"""
+                    <tr data-pattern-type="{pattern_type}">
+                        <td class="sequence">{seq_str}</td>
+                        <td><span class="badge pattern-{pattern_type}">{pattern_type}</span></td>
+                        <td>{count}</td>
+                        <td>{first} / {last}</td>
+                    </tr>"""
+
+            patterns_html += """
+                </tbody>
+            </table>
+        </section>"""
+
         title = self.title or f"Session {self.id}"
 
         return f'''<!DOCTYPE html>
@@ -1406,7 +1458,7 @@ class Session(BaseModel):
                 <span class="badge">{self.event_count} events</span>
             </div>
         </header>
-{edges_html}{handoff_html}{context_html}{activity_html}
+{edges_html}{handoff_html}{context_html}{patterns_html}{activity_html}
     </article>
 </body>
 </html>

htmlgraph/sdk.py

@@ -44,7 +44,7 @@ from typing import Any
 
 from htmlgraph.agent_detection import detect_agent_name
 from htmlgraph.agents import AgentInterface
-from htmlgraph.analytics import Analytics, DependencyAnalytics
+from htmlgraph.analytics import Analytics, CrossSessionAnalytics, DependencyAnalytics
 from htmlgraph.collections import (
     BaseCollection,
     BugCollection,
@@ -242,6 +242,9 @@ class SDK:
         # Dependency analytics interface (Advanced graph analytics)
         self.dep_analytics = DependencyAnalytics(self._graph)
 
+        # Cross-session analytics interface (Git commit-based analytics)
+        self.cross_session_analytics = CrossSessionAnalytics(self)
+
         # Context analytics interface (Context usage tracking)
         self.context = ContextAnalytics(self)
 

{htmlgraph-0.20.9.dist-info → htmlgraph-0.21.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlgraph
-Version: 0.20.9
+Version: 0.21.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.20.9.dist-info → htmlgraph-0.21.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
-htmlgraph/__init__.py,sha256=NE0E3gKujZpGFq5RtICsv15BVCLwgd15_ydZab_pB9c,4979
+htmlgraph/__init__.py,sha256=AbgvM2vQ2nTI1DHlLsxmhhXZgrxmLxgwr5stbc25ZSc,4979
 htmlgraph/agent_detection.py,sha256=PAYo7rU3N_y1cGRd7Dwjh5Wgu-QZ7ENblX_yOzU-gJ0,2749
 htmlgraph/agent_registry.py,sha256=Usa_35by7p5gtpvHO7K3AcGimnorw-FzgPVa3cWTQ58,9448
 htmlgraph/agents.py,sha256=Yvu6x1nOfrW2WhRTAHiCuSpvqoVJXx1Mkzd59kwEczw,33466
 htmlgraph/analytics_index.py,sha256=ba6Y4H_NNOCxI_Z4U7wSgBFFairf4IJT74WcM1PoZuI,30594
 htmlgraph/attribute_index.py,sha256=cBZUV4YfGnhh6lF59aYPCdNrRr1hK__BzSKCueSDUhQ,6593
-htmlgraph/cli.py,sha256=wYoCjciu1cHqwZe84u2TgO7lS_YyTs4yX5ipLLUqUfo,173218
+htmlgraph/cli.py,sha256=6CwzcFZ6tOlYCS1521gvFkwVw4qb9XSLvq-eqb2Mz8I,182068
 htmlgraph/context_analytics.py,sha256=CaLu0o2uSr6rlBM5YeaFZe7grgsy7_Hx10qdXuNcdao,11344
-htmlgraph/converter.py,sha256=Yeg31k2tiVlQLVndGIBxQT21YvepDIDIuswZRicYR10,20630
+htmlgraph/converter.py,sha256=OfcydZcJqvr2jpMxvAD4wcq8o4NXC7w4X4QzdDiYq8k,22277
 htmlgraph/dashboard.html,sha256=rkZYjSnPbUuAm35QMpCNWemenYqQTdkkumCX2hhe8Dc,173537
 htmlgraph/dependency_models.py,sha256=eKpBz9y_pTE5E8baESqHyGUDj5-uXokVd2Bx3ZogAyM,4313
 htmlgraph/deploy.py,sha256=kM_IMa3PmKpQf4YVH57aL9uV5IfpVJgaj-IFsgAKIbY,17771
@@ -21,9 +21,9 @@ htmlgraph/git_events.py,sha256=62lmhGc7W1KGXAcW_Efpd_v2nIuUl0a4Ggpf73RyRmY,20271
 htmlgraph/graph.py,sha256=XhPuUYwhrCFVBEijjOdcHjjMEUlduba39CyzZ9dJ6X0,68187
 htmlgraph/ids.py,sha256=ibEC8xW1ZHbAW6ImOKP2wLARgW7nzkxu8voce_hkljk,8389
 htmlgraph/index.d.ts,sha256=7dvExfA16g1z5Kut8xyHnSUfZ6wiUUwWNy6R7WKiwas,6922
-htmlgraph/learning.py,sha256=Esgxovf7dVtubqswJ0T_sdLzcVN49yF8gCJ1AuHgHSg,27865
+htmlgraph/learning.py,sha256=6SsRdz-xJGFPjp7YagpUDTZqqjNKp2wWihcnhwkHys0,28566
 htmlgraph/mcp_server.py,sha256=AeJeGJEtX5Dqu5rfhKfT5kwF2Oe8V8xCaP8BgMEh86s,24033
-htmlgraph/models.py,sha256=yz5GrSRvQCC2Qy2ozOOfNm5Tw6mXaXZaACkajSjJnqg,79911
+htmlgraph/models.py,sha256=tgFFFwOuEe7Yal5I1JTZHJnF625oaHMATEGIvJgrFnk,81818
 htmlgraph/orchestration.py,sha256=7_oQ4AlHOv14hs6RvLsatJzF-F5gkIbv1EOrmeGPhiw,9699
 htmlgraph/orchestrator.py,sha256=6mj70vroWjmNmdvQ7jqqRSA9O1rFUNMUYDWPzqkizLk,19697
 htmlgraph/orchestrator_mode.py,sha256=F6LNZARqieQXUri3CRSq_lsqFbnVeGXJQPno1ZP47O4,9187
@@ -33,7 +33,7 @@ htmlgraph/parser.py,sha256=w5JIYvS8XmUGGsp-YC2ZWAJANS6hvQtvBxOYy9mL-Rs,13934
 htmlgraph/planning.py,sha256=iqPF9mCVQwOfJ4vuqcF2Y3-yhx9koJZw0cID7CknIug,35903
 htmlgraph/query_builder.py,sha256=aNtJ05GpGl9yUSSrX0D6pX_AgqlrrH-CulI_oP11PUk,18092
 htmlgraph/routing.py,sha256=QYDY6bzYPmv6kocAXCqguB1cazN0i_xTo9EVCO3fO2Y,8803
-htmlgraph/sdk.py,sha256=048GzLYdnrw6eUvF2B_A9mRFrrP2od_uiTbD0JrUkFo,82401
+htmlgraph/sdk.py,sha256=mcJh1cZO9xB2iPJwFQJRnMb5ylr_qmd7c_YgLvgUWRo,82565
 htmlgraph/server.py,sha256=ti_ROzVxc3b4TGylHZ5uzfgax3OHyBoyeJxAaeMfdAo,49297
 htmlgraph/session_manager.py,sha256=8_H29kN6Btii1RfzNpifjjUVTMU0cEeTElFsDC6icLM,89430
 htmlgraph/session_warning.py,sha256=leAYNp8pOkPFosIvNkY4Y3vjs1j76F3pGktUqQX9tI0,7877
@@ -48,10 +48,16 @@ htmlgraph/transcript_analytics.py,sha256=O-T7SfM3gJIbGFNPlF3gmKjcy--NzPiJt03lvTC
 htmlgraph/types.py,sha256=EBxCbke3PhORsmIhHrD-f1XG6YPRX-1D5R1OXCp6xt8,8945
 htmlgraph/watch.py,sha256=xsiZwDVaXZ6vXI_oOZMqMF78aeAgxuhKpxiz98Hryqg,3791
 htmlgraph/work_type_utils.py,sha256=exA3FnuSmVMMMSBhPYDW-Bq5jGaTDjX7jkckCvnVZ_s,3408
-htmlgraph/analytics/__init__.py,sha256=_IaNrc3mY3eNgUv5UYU67sKy2enuBHXL0_vA9njAgH8,287
+htmlgraph/analytics/__init__.py,sha256=G_DvCaiAeYVfMWFri1GOfLNF7PtAhitKa2V9TXHtsds,409
 htmlgraph/analytics/cli.py,sha256=ujHhMnI13eDJQKBywPNFfUkq_p2vNEG16P_a6vAx0U0,13017
+htmlgraph/analytics/cross_session.py,sha256=KjDohOPigkHrwI_bnDr3v5MIIgx_bSEIIxXK3UcQoaM,20472
 htmlgraph/analytics/dependency.py,sha256=7Qc5xe0b1QE_P6-l4Z0WtstEmEXc4ZGNbyIEBMoABys,25757
 htmlgraph/analytics/work_type.py,sha256=nMuUmC0rV4gvu2eovCBuR-JEnsCzk6nWnB4_zIfbJ9s,17594
+htmlgraph/archive/__init__.py,sha256=F5VpZNiKar5J1e6caWhB7P7QQ4xvsyhDHtH65Q3224c,661
+htmlgraph/archive/bloom.py,sha256=8OL-apF3BGW1V1P9vgi6vk_IHlJe3JOxigMRyuLMjys,7058
+htmlgraph/archive/fts.py,sha256=HZSNb0GYwfm_KA6BlR72LcaAfXWsUPAi0f4BC7IJcRo,9193
+htmlgraph/archive/manager.py,sha256=FPYVvgi5xbFIJtveV25KxHmczozfKDZiq0D76k_wHjo,18256
+htmlgraph/archive/search.py,sha256=stfT296q0fqHUtW9pFQ8yJ034jq3dobEt1_qZQ21A4U,7183
 htmlgraph/builders/__init__.py,sha256=a65xHw2ARqK8oMVS1YNsIS4FAO17nBe2TFcceUqhyc0,949
 htmlgraph/builders/base.py,sha256=iLAE7oTySX8psnFbX1dauDyhrCNTCXa-D_bpM7Ymh_8,7255
 htmlgraph/builders/bug.py,sha256=RzLkMPoRvZQkBK3odZ2MYXdUHc-HgTLE4v0lOn6vyJU,3380
@@ -107,12 +113,12 @@ htmlgraph/services/claiming.py,sha256=HcrltEJKN72mxuD7fGuXWeh1U0vwhjMvhZcFc02Eiy
 htmlgraph/templates/AGENTS.md.template,sha256=f96h7V6ygwj-v-fanVI48eYMxR6t_se4bet1H4ZsDpI,7642
 htmlgraph/templates/CLAUDE.md.template,sha256=h1kG2hTX2XYig2KszsHBfzrwa_4Cfcq2Pj4SwqzeDlM,1984
 htmlgraph/templates/GEMINI.md.template,sha256=gAGzE53Avki87BM_otqy5HdcYCoLsHgqaKjVzNzPMX8,1622
-htmlgraph-0.20.9.data/data/htmlgraph/dashboard.html,sha256=rkZYjSnPbUuAm35QMpCNWemenYqQTdkkumCX2hhe8Dc,173537
-htmlgraph-0.20.9.data/data/htmlgraph/styles.css,sha256=oDUSC8jG-V-hKojOBO9J88hxAeY2wJrBYTq0uCwX_Y4,7135
-htmlgraph-0.20.9.data/data/htmlgraph/templates/AGENTS.md.template,sha256=f96h7V6ygwj-v-fanVI48eYMxR6t_se4bet1H4ZsDpI,7642
-htmlgraph-0.20.9.data/data/htmlgraph/templates/CLAUDE.md.template,sha256=h1kG2hTX2XYig2KszsHBfzrwa_4Cfcq2Pj4SwqzeDlM,1984
-htmlgraph-0.20.9.data/data/htmlgraph/templates/GEMINI.md.template,sha256=gAGzE53Avki87BM_otqy5HdcYCoLsHgqaKjVzNzPMX8,1622
-htmlgraph-0.20.9.dist-info/METADATA,sha256=RxbHkLwWMN4ZBOO1Aw7P_gC1goCeH0rK0wGAIPrYbLc,7645
-htmlgraph-0.20.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-htmlgraph-0.20.9.dist-info/entry_points.txt,sha256=EaUbjA_bbDwEO_XDLEGMeK8aQP-ZnHiUTkLshyKDyB8,98
-htmlgraph-0.20.9.dist-info/RECORD,,
+htmlgraph-0.21.0.data/data/htmlgraph/dashboard.html,sha256=rkZYjSnPbUuAm35QMpCNWemenYqQTdkkumCX2hhe8Dc,173537
+htmlgraph-0.21.0.data/data/htmlgraph/styles.css,sha256=oDUSC8jG-V-hKojOBO9J88hxAeY2wJrBYTq0uCwX_Y4,7135
+htmlgraph-0.21.0.data/data/htmlgraph/templates/AGENTS.md.template,sha256=f96h7V6ygwj-v-fanVI48eYMxR6t_se4bet1H4ZsDpI,7642
+htmlgraph-0.21.0.data/data/htmlgraph/templates/CLAUDE.md.template,sha256=h1kG2hTX2XYig2KszsHBfzrwa_4Cfcq2Pj4SwqzeDlM,1984
+htmlgraph-0.21.0.data/data/htmlgraph/templates/GEMINI.md.template,sha256=gAGzE53Avki87BM_otqy5HdcYCoLsHgqaKjVzNzPMX8,1622
+htmlgraph-0.21.0.dist-info/METADATA,sha256=imvjH4WNDmGZNWZ9atUaBoHlxiOfjlAxGrzE0XfHoY8,7645
+htmlgraph-0.21.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+htmlgraph-0.21.0.dist-info/entry_points.txt,sha256=EaUbjA_bbDwEO_XDLEGMeK8aQP-ZnHiUTkLshyKDyB8,98
+htmlgraph-0.21.0.dist-info/RECORD,,