tzero-mcp 10.7.0 → 10.7.1

package/src/tzero_jarvis/causal_graph.py

@@ -0,0 +1,310 @@
+# -*- coding: utf-8 -*-
+"""
+T-ZERO CAUSAL & TEMPORAL KNOWLEDGE GRAPH ENGINE (4D GRAPH)
+Developer: Toprak Ahmet Aydoğmuş (Siber Akademi)
+Version: 4.4.0
+
+Bu modül, anlamsal üçlüleri (Semantic Triplet) 4 boyutlu uzayda (zaman + nedensellik)
+birleştiren akıllı çizge motorudur.
+
+Temel Yetenekler:
+1. Zamansal Sıralama (Temporal Sequencing): precedes, follows, simultaneous, timestamping
+2. Nedensellik Bağları (Causal Edges): causes, triggered_by, fixes, resolves, mitigates, fails_with
+3. Kök Neden Analizi (Root-Cause Analysis via Causal DAG Traversal)
+4. Geri Alma Sıralaması (Rollback Order Planning)
+5. Döngü Tespiti (Causal Cycle Detection)
+"""
+
+from __future__ import annotations
+import time
+import json
+from typing import Dict, List, Optional, Set, Tuple, Any
+from dataclasses import dataclass, field, asdict
+from tzero_jarvis.semantic_compressor import SemanticTriplet, TypedEntity, EntityType, VectorQuantizedCodebook
+
+
+class CausalRelationType:
+    CAUSES = "causes"             # A -> B (A, B'ye sebep oldu)
+    TRIGGERED_BY = "triggered_by" # B <- A (B, A tarafından tetiklendi)
+    FIXES = "fixes"               # A -> B (A, B hatasını/sorununu çözdü)
+    RESOLVES = "resolves"         # Eş anlamlı: çözüme kavuşturdu
+    MITIGATES = "mitigates"       # A, B'nin etkisini hafifletti
+    FAILS_WITH = "fails_with"     # A eylemi B hatasıyla sonuçlandı
+    PRECEDES = "precedes"         # A zaman olarak B'den önce gerçekleşti
+    FOLLOWS = "follows"           # A zaman olarak B'den sonra gerçekleşti
+    CORRELATED_WITH = "correlated_with" # İstatistiki ilişki
+
+
+@dataclass
+class CausalEdge:
+    source_id: str
+    target_id: str
+    relation: str
+    weight: float = 1.0
+    timestamp: float = field(default_factory=time.time)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class CausalNode:
+    node_id: str
+    label: str
+    entity_type: str = "GENERIC"
+    triplet_code: Optional[int] = None
+    timestamp: float = field(default_factory=time.time)
+    attributes: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+class CausalTemporalGraph:
+    """
+    4 Boyutlu Nedensellik ve Zaman Çizgesi Motoru.
+    Gelişmiş DAG algoritmaları ile kök neden ve geri alma zincirlerini hesaplar.
+    """
+
+    def __init__(self, codebook: Optional[VectorQuantizedCodebook] = None):
+        self.codebook = codebook or VectorQuantizedCodebook()
+        self.nodes: Dict[str, CausalNode] = {}
+        self.outgoing_edges: Dict[str, List[CausalEdge]] = {}
+        self.incoming_edges: Dict[str, List[CausalEdge]] = {}
+        self.chronological_timeline: List[str] = [] # node_id list in temporal order
+
+    def add_node(self, node_id: str, label: str, entity_type: str = "GENERIC",
+                 triplet_code: Optional[int] = None, timestamp: Optional[float] = None,
+                 attributes: Optional[Dict[str, Any]] = None) -> CausalNode:
+        ts = timestamp if timestamp is not None else time.time()
+        node = CausalNode(
+            node_id=node_id,
+            label=label,
+            entity_type=entity_type,
+            triplet_code=triplet_code,
+            timestamp=ts,
+            attributes=attributes or {}
+        )
+        self.nodes[node_id] = node
+        if node_id not in self.outgoing_edges:
+            self.outgoing_edges[node_id] = []
+        if node_id not in self.incoming_edges:
+            self.incoming_edges[node_id] = []
+        
+        # Zaman çizgisine ekle
+        self.chronological_timeline.append(node_id)
+        self.chronological_timeline.sort(key=lambda nid: self.nodes[nid].timestamp)
+        return node
+
+    def add_edge(self, source_id: str, target_id: str, relation: str = CausalRelationType.CAUSES,
+                 weight: float = 1.0, metadata: Optional[Dict[str, Any]] = None) -> CausalEdge:
+        if source_id not in self.nodes:
+            self.add_node(source_id, source_id)
+        if target_id not in self.nodes:
+            self.add_node(target_id, target_id)
+
+        edge = CausalEdge(
+            source_id=source_id,
+            target_id=target_id,
+            relation=relation,
+            weight=weight,
+            timestamp=time.time(),
+            metadata=metadata or {}
+        )
+        self.outgoing_edges[source_id].append(edge)
+        self.incoming_edges[target_id].append(edge)
+        return edge
+
+    def record_triplet_event(self, triplet: SemanticTriplet,
+                             preceding_triplet_code: Optional[int] = None,
+                             causes_triplet_code: Optional[int] = None) -> Tuple[int, str]:
+        """
+        Bir semantik üçlüyü çizgeye zamansal düğüm olarak ekler ve nedensellik bağlarını kurar.
+        """
+        code = self.codebook.encode(triplet)
+        node_id = f"node_{code}_{int(time.time() * 1000) % 100000}"
+        label = f"({triplet.subject})->[{triplet.predicate}]->({','.join(o.name for o in triplet.objects)})"
+        
+        # Ana entity domain belirle
+        primary_domain = "GENERIC"
+        if triplet.objects:
+            primary_domain = triplet.objects[0].entity_type.value
+        elif triplet.contexts:
+            primary_domain = triplet.contexts[0].entity_type.value
+
+        self.add_node(
+            node_id=node_id,
+            label=label,
+            entity_type=primary_domain,
+            triplet_code=code,
+            attributes={"subject": triplet.subject, "predicate": triplet.predicate}
+        )
+
+        # Önceki olayla zamansal bağ
+        if preceding_triplet_code is not None:
+            prev_nodes = [nid for nid, n in self.nodes.items() if n.triplet_code == preceding_triplet_code]
+            if prev_nodes:
+                latest_prev = prev_nodes[-1]
+                self.add_edge(latest_prev, node_id, relation=CausalRelationType.PRECEDES)
+
+        # Neden-sonuç bağı
+        if causes_triplet_code is not None:
+            cause_nodes = [nid for nid, n in self.nodes.items() if n.triplet_code == causes_triplet_code]
+            if cause_nodes:
+                latest_cause = cause_nodes[-1]
+                self.add_edge(latest_cause, node_id, relation=CausalRelationType.CAUSES)
+
+        return code, node_id
+
+    def get_root_causes(self, target_node_id: str, max_depth: int = 10) -> List[Dict[str, Any]]:
+        """
+        Hedef düğümün (örn: bir hata veya arıza durumu) tüm kök nedenlerini (Root Causes)
+        nedensellik çizgisi boyunca geriye doğru izleyerek bulur.
+        """
+        if target_node_id not in self.nodes:
+            return []
+
+        visited: Set[str] = set()
+        root_causes: List[Dict[str, Any]] = []
+
+        def dfs(curr_id: str, depth: int, path: List[str]):
+            if depth >= max_depth or curr_id in visited:
+                return
+            visited.add(curr_id)
+
+            incoming = self.incoming_edges.get(curr_id, [])
+            causal_incoming = [
+                e for e in incoming 
+                if e.relation in (CausalRelationType.CAUSES, CausalRelationType.TRIGGERED_BY, CausalRelationType.PRECEDES)
+            ]
+
+            if not causal_incoming and depth > 0:
+                # Kök nedene ulaşıldı
+                node = self.nodes[curr_id]
+                root_causes.append({
+                    "root_node_id": curr_id,
+                    "label": node.label,
+                    "entity_type": node.entity_type,
+                    "triplet_code": node.triplet_code,
+                    "causal_path": list(reversed(path + [curr_id])),
+                    "depth": depth
+                })
+                return
+
+            for edge in causal_incoming:
+                dfs(edge.source_id, depth + 1, path + [curr_id])
+
+        dfs(target_node_id, 0, [])
+        return root_causes
+
+    def trace_effect_chain(self, start_node_id: str, max_depth: int = 10) -> List[Dict[str, Any]]:
+        """
+        Başlangıç düğümünün tetiklediği tüm zincirleme sonuçları (Downstream Effects) çıkarır.
+        """
+        if start_node_id not in self.nodes:
+            return []
+
+        chain: List[Dict[str, Any]] = []
+        queue: List[Tuple[str, int, List[str]]] = [(start_node_id, 0, [start_node_id])]
+        visited: Set[str] = {start_node_id}
+
+        while queue:
+            curr_id, depth, path = queue.pop(0)
+            if depth >= max_depth:
+                continue
+
+            for edge in self.outgoing_edges.get(curr_id, []):
+                next_id = edge.target_id
+                if next_id not in visited:
+                    visited.add(next_id)
+                    next_node = self.nodes.get(next_id)
+                    if next_node:
+                        chain.append({
+                            "node_id": next_id,
+                            "label": next_node.label,
+                            "relation": edge.relation,
+                            "depth": depth + 1,
+                            "path": path + [next_id]
+                        })
+                        queue.append((next_id, depth + 1, path + [next_id]))
+
+        return chain
+
+    def compute_rollback_order(self, target_node_id: str) -> List[Dict[str, Any]]:
+        """
+        Bir hata durumunda veya işlemin geri alınması gerektiğinde,
+        ters topolojik sıralama (Reverse Topological Order) ile güvenli geri alma adımlarını hesaplar.
+        """
+        effects = self.trace_effect_chain(target_node_id)
+        # En derin/en son etkilenen düğümden başlayarak geri alma planı
+        rollback_steps = []
+        for item in reversed(effects):
+            rollback_steps.append({
+                "step": len(rollback_steps) + 1,
+                "action": f"Rollback: {item['label']}",
+                "node_id": item["node_id"],
+                "relation_to_reverse": item["relation"]
+            })
+        
+        target_node = self.nodes.get(target_node_id)
+        if target_node:
+            rollback_steps.append({
+                "step": len(rollback_steps) + 1,
+                "action": f"Revert Base: {target_node.label}",
+                "node_id": target_node_id,
+                "relation_to_reverse": "initial_trigger"
+            })
+        return rollback_steps
+
+    def get_timeline(self, limit: int = 50) -> List[Dict[str, Any]]:
+        """
+        Kronolojik olay akışını döndürür.
+        """
+        results = []
+        for nid in self.chronological_timeline[-limit:]:
+            node = self.nodes[nid]
+            results.append({
+                "node_id": nid,
+                "label": node.label,
+                "entity_type": node.entity_type,
+                "triplet_code": node.triplet_code,
+                "timestamp": node.timestamp,
+                "outgoing_count": len(self.outgoing_edges.get(nid, [])),
+                "incoming_count": len(self.incoming_edges.get(nid, []))
+            })
+        return results
+
+    def to_graph_data(self) -> Dict[str, Any]:
+        """
+        Görselleştirme için nodes ve links JSON verisi üretir.
+        """
+        nodes_data = []
+        for nid, node in self.nodes.items():
+            nodes_data.append({
+                "id": nid,
+                "label": node.label,
+                "group": node.entity_type,
+                "code": node.triplet_code,
+                "timestamp": node.timestamp
+            })
+
+        links_data = []
+        for src, edges in self.outgoing_edges.items():
+            for e in edges:
+                links_data.append({
+                    "source": e.source_id,
+                    "target": e.target_id,
+                    "relation": e.relation,
+                    "weight": e.weight
+                })
+
+        return {
+            "nodes": nodes_data,
+            "links": links_data,
+            "stats": {
+                "total_nodes": len(self.nodes),
+                "total_edges": sum(len(el) for el in self.outgoing_edges.values()),
+                "timeline_events": len(self.chronological_timeline)
+            }
+        }

package/src/tzero_jarvis/graph_visualizer.py

@@ -0,0 +1,395 @@
+# -*- coding: utf-8 -*-
+"""
+T-ZERO CYBERPUNK KNOWLEDGE & CAUSAL GRAPH VISUALIZER
+Developer: Toprak Ahmet Aydoğmuş (Siber Akademi)
+Version: 4.4.0
+
+Bu modül, T-Zero 4D Nedensellik ve Bilgi Çizgesini tamamen bağımsız (Offline),
+neon siberpunk estetiğine sahip interaktif bir HTML5 / SVG Force-Directed Graph
+olarak render eder ve dışa aktarır.
+"""
+
+from __future__ import annotations
+import os
+import json
+from typing import Dict, List, Optional, Any
+from tzero_jarvis.causal_graph import CausalTemporalGraph
+
+
+DOMAIN_COLORS = {
+    "HARDWARE": "#38bdf8",
+    "PROTOCOL": "#818cf8",
+    "SOFTWARE": "#60a5fa",
+    "VULN": "#f43f5e",
+    "BIO": "#34d399",
+    "CRYPTO": "#fbbf24",
+    "QUANTUM": "#a78bfa",
+    "AEROSPACE": "#fb923c",
+    "AUTOMOTIVE": "#38bdf8",
+    "FINANCE": "#4ade80",
+    "ROBOTICS": "#f87171",
+    "GENERIC": "#94a3b8"
+}
+
+
+class CyberpunkGraphVisualizer:
+    """
+    Siberpunk Temalı Çizge Görselleştirici.
+    Hiçbir CDN veya internet bağlantısına ihtiyaç duymadan saf HTML5/SVG/Canvas üretir.
+    """
+
+    def __init__(self, causal_graph: Optional[CausalTemporalGraph] = None):
+        self.causal_graph = causal_graph or CausalTemporalGraph()
+
+    def generate_html(self, title: str = "T-ZERO JARVIS KNOWLEDGE & CAUSAL GRAPH") -> str:
+        graph_data = self.causal_graph.to_graph_data()
+        json_payload = json.dumps(graph_data, ensure_ascii=False)
+        colors_payload = json.dumps(DOMAIN_COLORS, ensure_ascii=False)
+
+        html = f"""<!DOCTYPE html>
+<html lang="tr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{title}</title>
+    <style>
+        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
+        body {{
+            background: #090d16;
+            color: #f8fafc;
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+            overflow: hidden;
+            height: 100vh;
+            width: 100vw;
+        }}
+        #header {{
+            position: absolute;
+            top: 15px;
+            left: 20px;
+            z-index: 100;
+            background: rgba(15, 23, 42, 0.88);
+            backdrop-filter: blur(8px);
+            padding: 12px 20px;
+            border: 1px solid #1e293b;
+            border-radius: 8px;
+            box-shadow: 0 4px 16px rgba(0, 0, 0, 0.4);
+            pointer-events: auto;
+        }}
+        #header h1 {{ font-size: 15px; font-weight: 600; letter-spacing: 0.5px; color: #f8fafc; }}
+        #header p {{ font-size: 12px; color: #94a3b8; margin-top: 4px; }}
+        #controls {{
+            position: absolute;
+            top: 15px;
+            right: 20px;
+            z-index: 100;
+            background: rgba(15, 23, 42, 0.88);
+            backdrop-filter: blur(8px);
+            padding: 10px 15px;
+            border: 1px solid #1e293b;
+            border-radius: 8px;
+            box-shadow: 0 4px 16px rgba(0, 0, 0, 0.4);
+        }}
+        input[type="text"] {{
+            background: #0b1120;
+            border: 1px solid #334155;
+            color: #f8fafc;
+            padding: 7px 12px;
+            border-radius: 6px;
+            font-family: monospace;
+            font-size: 12px;
+            outline: none;
+            transition: border-color 0.15s ease;
+        }}
+        input[type="text"]:focus {{
+            border-color: #38bdf8;
+        }}
+        #stats-bar {{
+            position: absolute;
+            bottom: 15px;
+            left: 20px;
+            z-index: 100;
+            background: rgba(15, 23, 42, 0.88);
+            backdrop-filter: blur(8px);
+            padding: 8px 16px;
+            border: 1px solid #1e293b;
+            font-size: 12px;
+            color: #94a3b8;
+            border-radius: 6px;
+        }}
+        #inspector {{
+            position: absolute;
+            bottom: 15px;
+            right: 20px;
+            z-index: 100;
+            width: 320px;
+            max-height: 250px;
+            overflow-y: auto;
+            background: rgba(15, 23, 42, 0.95);
+            backdrop-filter: blur(10px);
+            border: 1px solid #334155;
+            padding: 14px;
+            font-size: 12px;
+            border-radius: 8px;
+            display: none;
+            box-shadow: 0 10px 25px rgba(0, 0, 0, 0.5);
+        }}
+        canvas {{ display: block; width: 100%; height: 100%; }}
+    </style>
+</head>
+<body>
+    <div id="header">
+        <h1>⚡ T-ZERO 4D KNOWLEDGE & CAUSAL GRAPH</h1>
+        <p>Developer: Toprak Ahmet Aydoğmuş | Zero-Cost Neural Engine</p>
+    </div>
+
+    <div id="controls">
+        <input type="text" id="searchInput" placeholder="Düğüm / Kod ara (örn: ESP32, #8421)..." oninput="filterGraph()">
+    </div>
+
+    <div id="stats-bar">
+        Düğümler: <span id="nodeCount" style="color:#38bdf8">0</span> | 
+        Bağlar: <span id="edgeCount" style="color:#818cf8">0</span> | 
+        FPS: <span id="fpsCount" style="color:#fbbf24">60</span>
+    </div>
+
+    <div id="inspector">
+        <h3 id="insTitle" style="color:#38bdf8; margin-bottom:6px;">Detay</h3>
+        <p id="insBody" style="color:#cbd5e1; line-height:1.5;"></p>
+    </div>
+
+    <canvas id="graphCanvas"></canvas>
+
+    <script>
+        const graphData = {json_payload};
+        const domainColors = {colors_payload};
+
+        const canvas = document.getElementById('graphCanvas');
+        const ctx = canvas.getContext('2d');
+        let width = canvas.width = window.innerWidth;
+        let height = canvas.height = window.innerHeight;
+
+        window.addEventListener('resize', () => {{
+            width = canvas.width = window.innerWidth;
+            height = canvas.height = window.innerHeight;
+        }});
+
+        document.getElementById('nodeCount').innerText = graphData.nodes.length;
+        document.getElementById('edgeCount').innerText = graphData.links.length;
+
+        // Düğümleri rastgele pozisyonlara yerleştir
+        const nodes = graphData.nodes.map((n, i) => {{
+            const angle = (i / Math.max(1, graphData.nodes.length)) * 2 * Math.PI;
+            const radius = 150 + Math.random() * 200;
+            return {{
+                ...n,
+                x: width / 2 + Math.cos(angle) * radius,
+                y: height / 2 + Math.sin(angle) * radius,
+                vx: 0,
+                vy: 0,
+                radius: n.code ? 18 : 12,
+                color: domainColors[n.group] || '#00ffcc'
+            }};
+        }});
+
+        const nodeMap = new Map();
+        nodes.forEach(n => nodeMap.set(n.id, n));
+
+        const links = graphData.links.map(l => ({{
+            ...l,
+            sourceNode: nodeMap.get(l.source),
+            targetNode: nodeMap.get(l.target)
+        }})).filter(l => l.sourceNode && l.targetNode);
+
+        // Basit Force-Directed Fizik Simülasyonu
+        let zoom = 1.0;
+        let panX = 0, panY = 0;
+        let selectedNode = null;
+        let isDragging = false;
+        let dragNode = null;
+
+        function simulate() {{
+            // İtme kuvveti
+            for (let i = 0; i < nodes.length; i++) {{
+                for (let j = i + 1; j < nodes.length; j++) {{
+                    const dx = nodes[j].x - nodes[i].x;
+                    const dy = nodes[j].y - nodes[i].y;
+                    const dist = Math.sqrt(dx * dx + dy * dy) || 1;
+                    if (dist < 300) {{
+                        const force = (300 - dist) / (dist * 15);
+                        nodes[i].vx -= dx * force;
+                        nodes[i].vy -= dy * force;
+                        nodes[j].vx += dx * force;
+                        nodes[j].vy += dy * force;
+                    }}
+                }}
+            }}
+
+            // Bağ çekme kuvveti
+            links.forEach(l => {{
+                const dx = l.targetNode.x - l.sourceNode.x;
+                const dy = l.targetNode.y - l.sourceNode.y;
+                const dist = Math.sqrt(dx * dx + dy * dy) || 1;
+                const force = (dist - 120) * 0.02;
+                l.sourceNode.vx += dx * force;
+                l.sourceNode.vy += dy * force;
+                l.targetNode.vx -= dx * force;
+                l.targetNode.vy -= dy * force;
+            }});
+
+            // Merkeze çekim ve sürtünme
+            nodes.forEach(n => {{
+                if (n === dragNode) return;
+                n.vx += (width / 2 - n.x) * 0.002;
+                n.vy += (height / 2 - n.y) * 0.002;
+                n.vx *= 0.85;
+                n.vy *= 0.85;
+                n.x += n.vx;
+                n.y += n.vy;
+            }});
+        }}
+
+        let lastFrameTime = performance.now();
+        let frameCount = 0;
+
+        function render() {{
+            simulate();
+
+            ctx.clearRect(0, 0, width, height);
+            ctx.save();
+            ctx.translate(panX, panY);
+            ctx.scale(zoom, zoom);
+
+            // Bağları çiz
+            links.forEach(l => {{
+                ctx.beginPath();
+                ctx.moveTo(l.sourceNode.x, l.sourceNode.y);
+                ctx.lineTo(l.targetNode.x, l.targetNode.y);
+                ctx.strokeStyle = l.relation === 'causes' ? 'rgba(255, 0, 85, 0.6)' : 'rgba(0, 229, 255, 0.4)';
+                ctx.lineWidth = l.relation === 'causes' ? 2 : 1;
+                ctx.stroke();
+
+                // İlişki etiketi
+                const midX = (l.sourceNode.x + l.targetNode.x) / 2;
+                const midY = (l.sourceNode.y + l.targetNode.y) / 2;
+                ctx.font = '9px monospace';
+                ctx.fillStyle = '#80d8ff';
+                ctx.fillText(l.relation, midX, midY);
+            }});
+
+            // Düğümleri çiz
+            nodes.forEach(n => {{
+                ctx.save();
+                ctx.shadowColor = n.color;
+                ctx.shadowBlur = 12;
+
+                ctx.beginPath();
+                ctx.arc(n.x, n.y, n.radius, 0, 2 * Math.PI);
+                ctx.fillStyle = n.color;
+                ctx.fill();
+
+                ctx.restore();
+
+                // Düğüm halkası
+                ctx.beginPath();
+                ctx.arc(n.x, n.y, n.radius + 3, 0, 2 * Math.PI);
+                ctx.strokeStyle = '#ffffff';
+                ctx.lineWidth = 1;
+                ctx.stroke();
+
+                // Metin etiketi
+                ctx.font = '10px Consolas, monospace';
+                ctx.fillStyle = '#ffffff';
+                ctx.textAlign = 'center';
+                const labelText = n.code ? `[#${{n.code}}] ${{n.label}}` : n.label;
+                ctx.fillText(labelText, n.x, n.y + n.radius + 14);
+            }});
+
+            ctx.restore();
+
+            // FPS sayacı
+            frameCount++;
+            const now = performance.now();
+            if (now - lastFrameTime >= 1000) {{
+                document.getElementById('fpsCount').innerText = frameCount;
+                frameCount = 0;
+                lastFrameTime = now;
+            }}
+
+            requestAnimationFrame(render);
+        }}
+
+        // Mouse Etkileşimi
+        canvas.addEventListener('mousedown', e => {{
+            const mx = (e.clientX - panX) / zoom;
+            const my = (e.clientY - panY) / zoom;
+            for (let n of nodes) {{
+                const dx = n.x - mx;
+                const dy = n.y - my;
+                if (Math.sqrt(dx * dx + dy * dy) < n.radius + 5) {{
+                    dragNode = n;
+                    selectedNode = n;
+                    showInspector(n);
+                    return;
+                }}
+            }}
+            isDragging = true;
+            dragStartX = e.clientX - panX;
+            dragStartY = e.clientY - panY;
+        }});
+
+        canvas.addEventListener('mousemove', e => {{
+            if (dragNode) {{
+                dragNode.x = (e.clientX - panX) / zoom;
+                dragNode.y = (e.clientY - panY) / zoom;
+            }} else if (isDragging) {{
+                panX = e.clientX - dragStartX;
+                panY = e.clientY - dragStartY;
+            }}
+        }});
+
+        canvas.addEventListener('mouseup', () => {{
+            dragNode = null;
+            isDragging = false;
+        }});
+
+        canvas.addEventListener('wheel', e => {{
+            e.preventDefault();
+            const factor = e.deltaY < 0 ? 1.1 : 0.9;
+            zoom *= factor;
+            zoom = Math.min(Math.max(0.2, zoom), 4.0);
+        }});
+
+        function showInspector(node) {{
+            const ins = document.getElementById('inspector');
+            ins.style.display = 'block';
+            document.getElementById('insTitle').innerText = `${{node.group}}: ${{node.label}}`;
+            document.getElementById('insBody').innerHTML = `
+                <b>ID:</b> ${{node.id}}<br>
+                <b>Latent Code:</b> ${{node.code ? '#' + node.code : 'None'}}<br>
+                <b>Domain:</b> ${{node.group}}<br>
+                <b>Timestamp:</b> ${{new Date(node.timestamp * 1000).toLocaleTimeString()}}
+            `;
+        }}
+
+        function filterGraph() {{
+            const query = document.getElementById('searchInput').value.toLowerCase();
+            nodes.forEach(n => {{
+                const match = n.label.toLowerCase().includes(query) || (n.code && n.code.toString().includes(query));
+                n.color = match ? (domainColors[n.group] || '#00ffcc') : '#334155';
+                n.radius = match ? (n.code ? 20 : 14) : 8;
+            }});
+        }}
+
+        requestAnimationFrame(render);
+    </script>
+</body>
+</html>
+"""
+        return html
+
+    def export_to_file(self, target_path: str, title: str = "T-ZERO JARVIS KNOWLEDGE & CAUSAL GRAPH") -> str:
+        html = self.generate_html(title)
+        os.makedirs(os.path.dirname(os.path.abspath(target_path)), exist_ok=True)
+        with open(target_path, "w", encoding="utf-8") as f:
+            f.write(html)
+        return target_path