Create dvnc_flip_insight_patch.py

dvnc_flip_insight_patch.py

@@ -0,0 +1,227 @@
+"""
+Standalone non-destructive patch for DVNC.AI Hugging Face Space.
+
+Purpose
+- Fix Bug 1: hover/focus flip interaction makes the Flip Insight button unreliable.
+- Fix Bug 2: brittle Gradio element ID lookup for route swap payload/apply controls.
+- Fix Bug 3: route swap leaves timeline stale/blank by rebuilding/preserving the timeline output.
+
+Design
+- Leaves the existing codebase untouched.
+- Intended to be imported and applied from a separate runner or notebook.
+- Uses monkey-patching where possible.
+
+Usage example
+    import app as dvnc_app
+    import dvnc_flip_insight_patch as patch
+    patch.apply_patch(dvnc_app)
+
+If you want to keep the current app.py completely untouched, create a tiny launcher file
+that imports the original app module and then calls apply_patch(dvnc_app).
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Callable
+
+
+PATCH_SCRIPT = r"""
+<script>
+(function () {
+  if (window.__dvncFlipPatchLoaded) return;
+  window.__dvncFlipPatchLoaded = true;
+
+  function findByFragment(fragment) {
+    return document.getElementById(fragment) || document.querySelector('[id*="' + fragment + '"]');
+  }
+
+  function getInteractiveNode(root) {
+    if (!root) return null;
+    return root.matches?.('textarea,input,button') ? root : root.querySelector?.('textarea,input,button');
+  }
+
+  function triggerRouteSwapPatched(idx) {
+    try {
+      const payloadRoot = findByFragment('route_swap_payload');
+      const payload = getInteractiveNode(payloadRoot);
+      if (!payload) {
+        console.warn('[DVNC patch] route_swap_payload not found');
+        return;
+      }
+      payload.focus?.();
+      payload.value = String(idx);
+      ['input', 'change'].forEach(function (name) {
+        payload.dispatchEvent(new Event(name, { bubbles: true }));
+      });
+
+      window.setTimeout(function () {
+        const applyRoot = findByFragment('route_swap_apply');
+        const applyBtn = getInteractiveNode(applyRoot) || applyRoot;
+        if (!applyBtn) {
+          console.warn('[DVNC patch] route_swap_apply not found');
+          return;
+        }
+        applyBtn.click?.();
+      }, 180);
+    } catch (err) {
+      console.error('[DVNC patch] triggerRouteSwap failed', err);
+    }
+  }
+
+  window.triggerRouteSwap = triggerRouteSwapPatched;
+
+  document.addEventListener('click', function (e) {
+    const mini = e.target.closest('.candidate-back .mini');
+    if (mini) return;
+
+    const card = e.target.closest('.candidate-card');
+    if (!card) return;
+
+    card.classList.toggle('flipped');
+  }, true);
+
+  document.addEventListener('keydown', function (e) {
+    const card = e.target.closest && e.target.closest('.candidate-card');
+    if (!card) return;
+    if (e.key === 'Enter' || e.key === ' ') {
+      if (e.target.closest('.candidate-back .mini')) return;
+      e.preventDefault();
+      card.classList.toggle('flipped');
+    }
+  }, true);
+})();
+</script>
+"""
+
+PATCH_STYLE = r"""
+<style>
+.candidate-card { cursor: pointer; }
+.candidate-card.flipped .candidate-card-inner { transform: rotateY(180deg) !important; }
+.candidate-card:hover .candidate-card-inner,
+.candidate-card:focus .candidate-card-inner,
+.candidate-card:focus-within .candidate-card-inner { transform: none !important; }
+.candidate-back .mini { position: relative; z-index: 5; }
+</style>
+"""
+
+
+def _inject_assets(head: str) -> str:
+    if "__dvncFlipPatchLoaded" in head:
+        return head
+    return head + "\n" + PATCH_STYLE + "\n" + PATCH_SCRIPT
+
+
+def _patch_head(module: Any) -> None:
+    for attr in ("HEAD", "head", "CUSTOM_HEAD"):
+        if hasattr(module, attr):
+            value = getattr(module, attr)
+            if isinstance(value, str):
+                setattr(module, attr, _inject_assets(value))
+                return
+
+
+def _patch_cards_builder(module: Any) -> None:
+    if not hasattr(module, "build_cards_html"):
+        return
+    original = module.build_cards_html
+
+    def wrapped(*args, **kwargs):
+        out = original(*args, **kwargs)
+        if not isinstance(out, str):
+            return out
+        if "candidate-card" not in out:
+            return out
+
+        out = re.sub(
+            r'(<div\s+class="candidate-card"\b)',
+            r'\1 tabindex="0" role="button" aria-label="Flip insight card"',
+            out,
+            count=0,
+        )
+        return out
+
+    module.build_cards_html = wrapped
+
+
+def _build_timeline_from_state(module: Any, route_state: Any) -> Any:
+    if route_state is None:
+        return None
+
+    builder = getattr(module, "build_agent_route_cards_html", None)
+    if not callable(builder):
+        return None
+
+    try:
+        variants = route_state.get("variants") if isinstance(route_state, dict) else None
+        active_idx = route_state.get("active_variant", 0) if isinstance(route_state, dict) else 0
+        if not variants or active_idx >= len(variants):
+            return None
+        variant = variants[active_idx] or {}
+        steps = variant.get("steps") or variant.get("route") or []
+        if not steps:
+            return None
+
+        normalized = []
+        for i, step in enumerate(steps):
+            if isinstance(step, dict):
+                normalized.append(
+                    {
+                        "step": step.get("step", i + 1),
+                        "agent": step.get("agent", f"Step {i+1}"),
+                        "tag": step.get("tag", step.get("mode", "")),
+                        "summary": step.get("summary", step.get("description", "")),
+                    }
+                )
+            else:
+                normalized.append(
+                    {
+                        "step": i + 1,
+                        "agent": f"Step {i+1}",
+                        "tag": "",
+                        "summary": str(step),
+                    }
+                )
+        return builder(normalized)
+    except Exception:
+        return None
+
+
+def _patch_apply_route_swap(module: Any) -> None:
+    if not hasattr(module, "apply_route_swap"):
+        return
+
+    original = module.apply_route_swap
+
+    def wrapped(*args, **kwargs):
+        result = original(*args, **kwargs)
+        if not isinstance(result, tuple):
+            return result
+
+        if len(result) == 5:
+            chat_html, connectome_html, timeline_value, hypothesis_md, route_state = result
+            timeline_rebuilt = _build_timeline_from_state(module, route_state)
+            if timeline_rebuilt is not None:
+                gr = getattr(module, "gr", None)
+                if gr is not None and hasattr(gr, "update"):
+                    timeline_value = gr.update(value=timeline_rebuilt)
+                else:
+                    timeline_value = timeline_rebuilt
+            return chat_html, connectome_html, timeline_value, hypothesis_md, route_state
+        return result
+
+    module.apply_route_swap = wrapped
+
+
+def _patch_rendered_html(module: Any) -> None:
+    for attr in ("DISCOVERY_CARD_CSS",):
+        if hasattr(module, attr) and isinstance(getattr(module, attr), str):
+            setattr(module, attr, getattr(module, attr) + "\n" + PATCH_STYLE)
+
+
+def apply_patch(module: Any) -> Any:
+    _patch_head(module)
+    _patch_rendered_html(module)
+    _patch_cards_builder(module)
+    _patch_apply_route_swap(module)
+    return module