feat(observer): v15 AG Native chat relay — scanChatBodies dual strategy (#632)
- Add AG Native DOM path: #conversation + .leading-relaxed.select-text - Keep Cascade path: [data-testid=conversation-view] + [data-step-index] - Register #632 in known-issues.md (SDK+DOM both blocked for AG Native) - Bump version 0.5.50 → 0.5.51 - Add DOM analysis helper scripts
This commit is contained in:
Variet Worker
160
.agents/workflows/helpers/analyze_dom.py
Normal file
160
.agents/workflows/helpers/analyze_dom.py
Normal file
@@ -0,0 +1,160 @@
|
||||
"""Analyze AG Native DOM structure to find AI response containers."""
|
||||
import json, os, sys
|
||||
|
||||
def load_dump():
|
||||
bridge = os.path.join(os.path.expanduser('~'), '.gemini', 'antigravity', 'bridge')
|
||||
# Try deep-inspect result first, then dump_html
|
||||
for fname in ['deep-inspect-result.json', 'dump_html.json']:
|
||||
fpath = os.path.join(bridge, fname)
|
||||
if os.path.exists(fpath):
|
||||
print(f"Loading: {fname} ({os.path.getsize(fpath)} bytes)")
|
||||
with open(fpath, 'r', encoding='utf-8-sig') as f:
|
||||
return json.load(f), fname
|
||||
return None, None
|
||||
|
||||
def find_text_containers(node, path="", depth=0, results=None):
|
||||
"""Recursively find nodes with substantial text content (potential AI response containers)."""
|
||||
if results is None:
|
||||
results = []
|
||||
if not isinstance(node, dict):
|
||||
return results
|
||||
|
||||
tag = node.get('tag', '')
|
||||
cls = node.get('cls', '')
|
||||
text = node.get('text', '')
|
||||
attrs = node.get('attrs', {})
|
||||
children = node.get('children', [])
|
||||
|
||||
cur_path = f"{path}/{tag}"
|
||||
if cls:
|
||||
short_cls = cls[:60]
|
||||
cur_path += f".{short_cls}"
|
||||
|
||||
# Look for nodes with long text (potential AI responses)
|
||||
if text and len(text) > 50:
|
||||
results.append({
|
||||
'path': cur_path,
|
||||
'depth': depth,
|
||||
'tag': tag,
|
||||
'cls': cls[:100],
|
||||
'text_len': len(text),
|
||||
'text_preview': text[:120],
|
||||
'attrs': {k:v for k,v in attrs.items() if k not in ('style',)}
|
||||
})
|
||||
|
||||
for child in children:
|
||||
find_text_containers(child, cur_path, depth+1, results)
|
||||
|
||||
return results
|
||||
|
||||
def find_by_class_pattern(node, patterns, path="", depth=0, results=None):
|
||||
"""Find nodes matching class patterns."""
|
||||
if results is None:
|
||||
results = []
|
||||
if not isinstance(node, dict):
|
||||
return results
|
||||
|
||||
tag = node.get('tag', '')
|
||||
cls = node.get('cls', '')
|
||||
attrs = node.get('attrs', {})
|
||||
children = node.get('children', [])
|
||||
text = node.get('text', '')
|
||||
|
||||
cur_path = f"{path}/{tag}"
|
||||
|
||||
for pattern in patterns:
|
||||
if pattern.lower() in cls.lower() or pattern.lower() in str(attrs).lower():
|
||||
child_count = len(children)
|
||||
results.append({
|
||||
'path': cur_path,
|
||||
'depth': depth,
|
||||
'tag': tag,
|
||||
'cls': cls[:150],
|
||||
'pattern': pattern,
|
||||
'text_preview': text[:80] if text else '',
|
||||
'child_count': child_count,
|
||||
'attrs': {k:v[:50] for k,v in attrs.items() if k != 'style'}
|
||||
})
|
||||
|
||||
for child in children:
|
||||
find_by_class_pattern(child, patterns, cur_path, depth+1, results)
|
||||
|
||||
return results
|
||||
|
||||
def analyze_chat_structure(node, path="", depth=0):
|
||||
"""Find the chat/conversation area by looking at the main layout."""
|
||||
if not isinstance(node, dict):
|
||||
return
|
||||
tag = node.get('tag', '')
|
||||
cls = node.get('cls', '')
|
||||
children = node.get('children', [])
|
||||
text = node.get('text', '')
|
||||
attrs = node.get('attrs', {})
|
||||
|
||||
# Print interesting structural nodes at shallow depths
|
||||
if depth <= 6:
|
||||
child_count = len(children)
|
||||
has_text = bool(text and len(text) > 10)
|
||||
info = f"{' '*depth}{tag}"
|
||||
if cls:
|
||||
info += f" .{cls[:80]}"
|
||||
if attrs:
|
||||
attr_str = ' '.join(f'{k}={v[:30]}' for k,v in attrs.items() if k not in ('style','class'))
|
||||
if attr_str:
|
||||
info += f" [{attr_str}]"
|
||||
info += f" children={child_count}"
|
||||
if has_text:
|
||||
info += f" text=\"{text[:50]}...\""
|
||||
print(info)
|
||||
|
||||
for child in children:
|
||||
analyze_chat_structure(child, f"{path}/{tag}", depth+1)
|
||||
|
||||
data, fname = load_dump()
|
||||
if not data:
|
||||
print("No dump file found!")
|
||||
sys.exit(1)
|
||||
|
||||
# Handle both dump formats
|
||||
body = data.get('body', data)
|
||||
qi = data.get('quickInfo', {})
|
||||
|
||||
print("=" * 60)
|
||||
print("QUICK INFO")
|
||||
print("=" * 60)
|
||||
if qi:
|
||||
for k, v in qi.items():
|
||||
if k == 'buttons':
|
||||
print(f"buttons ({len(v)}):")
|
||||
for b in v[:15]:
|
||||
print(f" [{b.get('tag')}] \"{b.get('text','')[:50]}\" visible={b.get('visible')} cls={b.get('cls','')[:60]}")
|
||||
elif k == 'dataAttrs':
|
||||
print(f"dataAttrs: {v[:30]}")
|
||||
else:
|
||||
print(f"{k}: {v}")
|
||||
|
||||
print("\n" + "=" * 60)
|
||||
print("CHAT-RELATED CLASS PATTERNS")
|
||||
print("=" * 60)
|
||||
patterns = ['chat', 'message', 'conversation', 'response', 'answer', 'reply',
|
||||
'markdown', 'prose', 'content', 'panel', 'agent', 'assistant',
|
||||
'planner', 'step', 'trajectory', 'bot', 'ai-', 'turn']
|
||||
matches = find_by_class_pattern(body, patterns)
|
||||
for m in matches:
|
||||
print(f" [{m['tag']}] cls=\"{m['cls']}\" pattern={m['pattern']} children={m['child_count']} {m.get('attrs',{})}")
|
||||
|
||||
print("\n" + "=" * 60)
|
||||
print("LONG TEXT NODES (potential AI responses)")
|
||||
print("=" * 60)
|
||||
texts = find_text_containers(body)
|
||||
texts.sort(key=lambda x: x['text_len'], reverse=True)
|
||||
for t in texts[:20]:
|
||||
print(f" [{t['tag']}] depth={t['depth']} len={t['text_len']} cls=\"{t['cls'][:60]}\"")
|
||||
print(f" text: \"{t['text_preview']}\"")
|
||||
if t['attrs']:
|
||||
print(f" attrs: {t['attrs']}")
|
||||
|
||||
print("\n" + "=" * 60)
|
||||
print("DOM TREE (depth<=6)")
|
||||
print("=" * 60)
|
||||
analyze_chat_structure(body)
|
||||
19
.agents/workflows/helpers/parse_dump.py
Normal file
19
.agents/workflows/helpers/parse_dump.py
Normal file
@@ -0,0 +1,19 @@
|
||||
import json, os, sys
|
||||
|
||||
dump_path = os.path.join(os.path.expanduser('~'), '.gemini', 'antigravity', 'bridge', 'dump_html.json')
|
||||
with open(dump_path, 'r', encoding='utf-8') as f:
|
||||
data = json.load(f)
|
||||
|
||||
qi = data.get('quickInfo', {})
|
||||
print('=== Quick Info ===')
|
||||
print('hasConversationView:', qi.get('hasConversationView'))
|
||||
print('hasStepIndex:', qi.get('hasStepIndex'))
|
||||
print('hasBotColor:', qi.get('hasBotColor'))
|
||||
print('hasMarkdownBody:', qi.get('hasMarkdownBody'))
|
||||
print('hasProse:', qi.get('hasProse'))
|
||||
print('totalElements:', qi.get('totalElements'))
|
||||
print('dataTestIds:', qi.get('dataTestIds'))
|
||||
print('dataAttrs (first 20):', qi.get('dataAttrs', [])[:20])
|
||||
print('buttons (first 10):')
|
||||
for b in qi.get('buttons', [])[:10]:
|
||||
print(f" [{b.get('tag')}] {b.get('text', '')[:60]} visible={b.get('visible')}")
|
||||
83
.agents/workflows/helpers/search_dom.py
Normal file
83
.agents/workflows/helpers/search_dom.py
Normal file
@@ -0,0 +1,83 @@
|
||||
"""Search AG Native DOM dump for chat content and buttons."""
|
||||
import json, os
|
||||
|
||||
fpath = os.path.join(os.path.expanduser('~'), '.gemini', 'antigravity', 'bridge', 'dump_html_5.json')
|
||||
with open(fpath, 'r', encoding='utf-8-sig') as f:
|
||||
data = json.load(f)
|
||||
|
||||
body = data.get('body', data.get('bodyTree', {}))
|
||||
qi = data.get('quickInfo', {})
|
||||
|
||||
# Show all buttons
|
||||
print('=== BUTTONS ===')
|
||||
for b in qi.get('buttons', []):
|
||||
print(f' [{b["tag"]}] "{b["text"][:60]}" visible={b["visible"]} cls={b.get("cls","")[:80]}')
|
||||
|
||||
# Data attrs
|
||||
print('\n=== DATA ATTRS ===')
|
||||
for attr in qi.get('dataAttrs', []):
|
||||
print(f' {attr}')
|
||||
|
||||
# Recursive search for nodes by text
|
||||
def find_nodes_by_text(node, target, path='', results=None, depth=0):
|
||||
if results is None: results = []
|
||||
if not isinstance(node, dict): return results
|
||||
tag = node.get('tag','')
|
||||
cls = node.get('cls','')
|
||||
text = node.get('text','')
|
||||
children = node.get('children', [])
|
||||
cur = f'{path}/{tag}'
|
||||
if target.lower() in text.lower():
|
||||
results.append({'path': cur, 'depth': depth, 'cls': cls[:80], 'text': text[:80], 'children': len(children)})
|
||||
for c in children:
|
||||
find_nodes_by_text(c, target, cur, results, depth+1)
|
||||
return results
|
||||
|
||||
print('\n=== NODES containing "Always run" ===')
|
||||
matches = find_nodes_by_text(body, 'Always run')
|
||||
for m in matches:
|
||||
print(f' depth={m["depth"]} cls="{m["cls"]}" text="{m["text"]}" children={m["children"]}')
|
||||
|
||||
print('\n=== NODES containing "Always" ===')
|
||||
matches = find_nodes_by_text(body, 'Always')
|
||||
for m in matches:
|
||||
print(f' depth={m["depth"]} cls="{m["cls"]}" text="{m["text"]}" children={m["children"]}')
|
||||
|
||||
# Find ALL text nodes with > 30 chars
|
||||
def find_all_text(node, results=None, depth=0, path=''):
|
||||
if results is None: results = []
|
||||
if not isinstance(node, dict): return results
|
||||
tag = node.get('tag','')
|
||||
cls = node.get('cls','')
|
||||
text = node.get('text','')
|
||||
children = node.get('children', [])
|
||||
if text and len(text) > 30:
|
||||
results.append({'depth': depth, 'tag': tag, 'cls': cls[:80], 'text': text[:100], 'path': f'{path}/{tag}'})
|
||||
for c in children:
|
||||
find_all_text(c, results, depth+1, f'{path}/{tag}')
|
||||
return results
|
||||
|
||||
print('\n=== LONG TEXT NODES (>30 chars) ===')
|
||||
texts = find_all_text(body)
|
||||
texts.sort(key=lambda x: len(x['text']), reverse=True)
|
||||
for t in texts[:25]:
|
||||
print(f' d={t["depth"]} [{t["tag"]}] cls="{t["cls"][:50]}" len={len(t["text"])} "{t["text"][:80]}"')
|
||||
|
||||
# Find nodes with many children (structural containers)
|
||||
def find_containers(node, results=None, depth=0, path=''):
|
||||
if results is None: results = []
|
||||
if not isinstance(node, dict): return results
|
||||
tag = node.get('tag','')
|
||||
cls = node.get('cls','')
|
||||
children = node.get('children', [])
|
||||
if len(children) > 5:
|
||||
results.append({'depth': depth, 'tag': tag, 'cls': cls[:100], 'children': len(children), 'path': f'{path}/{tag}'})
|
||||
for c in children:
|
||||
find_containers(c, results, depth+1, f'{path}/{tag}')
|
||||
return results
|
||||
|
||||
print('\n=== CONTAINERS (>5 children) ===')
|
||||
conts = find_containers(body)
|
||||
conts.sort(key=lambda x: x['children'], reverse=True)
|
||||
for c in conts[:20]:
|
||||
print(f' d={c["depth"]} [{c["tag"]}] children={c["children"]} cls="{c["cls"][:70]}"')
|
||||
109
.agents/workflows/helpers/trace_dom.py
Normal file
109
.agents/workflows/helpers/trace_dom.py
Normal file
@@ -0,0 +1,109 @@
|
||||
"""Trace the DOM path from body to AI response container."""
|
||||
import json, os
|
||||
|
||||
fpath = os.path.join(os.path.expanduser('~'), '.gemini', 'antigravity', 'bridge', 'dump_html_5.json')
|
||||
with open(fpath, 'r', encoding='utf-8-sig') as f:
|
||||
data = json.load(f)
|
||||
|
||||
body = data.get('body', data.get('bodyTree', {}))
|
||||
|
||||
def find_path_to_class(node, target_cls, path=None, depth=0):
|
||||
"""Find the DOM path down to a node with a matching class."""
|
||||
if path is None: path = []
|
||||
if not isinstance(node, dict): return []
|
||||
|
||||
tag = node.get('tag', '')
|
||||
cls = node.get('cls', '')
|
||||
children = node.get('children', [])
|
||||
text = node.get('text', '')
|
||||
attrs = node.get('attrs', {})
|
||||
|
||||
entry = {
|
||||
'depth': depth,
|
||||
'tag': tag,
|
||||
'cls': cls[:120],
|
||||
'children': len(children),
|
||||
'text': text[:60] if text else '',
|
||||
'attrs': {k:v[:40] for k,v in attrs.items() if k not in ('style',)}
|
||||
}
|
||||
|
||||
if target_cls.lower() in cls.lower():
|
||||
return path + [entry]
|
||||
|
||||
for i, child in enumerate(children):
|
||||
result = find_path_to_class(child, target_cls, path + [entry], depth+1)
|
||||
if result:
|
||||
return result
|
||||
|
||||
return []
|
||||
|
||||
# Find path to the AI response container
|
||||
print("=== PATH TO 'leading-relaxed select-text' ===")
|
||||
path = find_path_to_class(body, 'leading-relaxed select-text')
|
||||
for p in path:
|
||||
indent = ' ' * p['depth']
|
||||
print(f'{indent}[{p["tag"]}] cls="{p["cls"]}" children={p["children"]} {p["attrs"]}')
|
||||
if p['text']:
|
||||
print(f'{indent} text: "{p["text"]}"')
|
||||
|
||||
# Now get the full subtree of the AI response container
|
||||
def get_subtree(node, target_cls, depth=0):
|
||||
if not isinstance(node, dict): return None
|
||||
cls = node.get('cls', '')
|
||||
if target_cls.lower() in cls.lower():
|
||||
return node
|
||||
for child in node.get('children', []):
|
||||
result = get_subtree(child, target_cls, depth+1)
|
||||
if result:
|
||||
return result
|
||||
return None
|
||||
|
||||
print("\n=== AI RESPONSE CONTAINER SUBTREE ===")
|
||||
container = get_subtree(body, 'leading-relaxed select-text')
|
||||
if container:
|
||||
def print_tree(node, depth=0, max_depth=4):
|
||||
if not isinstance(node, dict) or depth > max_depth: return
|
||||
tag = node.get('tag','')
|
||||
cls = node.get('cls','')[:80]
|
||||
text = node.get('text','')
|
||||
children = node.get('children', [])
|
||||
indent = ' ' * depth
|
||||
line = f'{indent}[{tag}]'
|
||||
if cls: line += f' cls="{cls}"'
|
||||
line += f' children={len(children)}'
|
||||
if text: line += f' text="{text[:60]}"'
|
||||
print(line)
|
||||
for c in children:
|
||||
print_tree(c, depth+1, max_depth)
|
||||
|
||||
print_tree(container, 0, 3)
|
||||
|
||||
# Also search for the chat panel container - what wraps the entire conversation
|
||||
print("\n=== SEARCH FOR CHAT PANEL WRAPPERS ===")
|
||||
chat_patterns = ['chat', 'antigravity', 'gemini', 'panel', 'agentview', 'sidebar', 'conversation']
|
||||
for pat in chat_patterns:
|
||||
path = find_path_to_class(body, pat)
|
||||
if path:
|
||||
last = path[-1]
|
||||
print(f' Pattern "{pat}" found at depth={last["depth"]} [{last["tag"]}] cls="{last["cls"]}" children={last["children"]}')
|
||||
|
||||
# Find the parent chain from body to the container - look by scanning ALL class names
|
||||
print("\n=== ALL UNIQUE CLASS NAMES (depth <= 12) ===")
|
||||
all_classes = set()
|
||||
def collect_classes(node, depth=0, max_depth=12):
|
||||
if not isinstance(node, dict) or depth > max_depth: return
|
||||
cls = node.get('cls', '')
|
||||
if cls:
|
||||
for c in cls.split():
|
||||
if len(c) > 3 and not c.startswith('{') and 'mtk' not in c:
|
||||
all_classes.add(c)
|
||||
for child in node.get('children', []):
|
||||
collect_classes(child, depth+1, max_depth)
|
||||
|
||||
collect_classes(body)
|
||||
# Print classes sorted, grouped by potential relevance
|
||||
relevant = sorted([c for c in all_classes if any(k in c.lower() for k in
|
||||
['chat', 'message', 'response', 'agent', 'gemini', 'turn', 'model', 'user', 'bot', 'conversation', 'markdown', 'prose', 'text-', 'content'])])
|
||||
print("Relevant classes:")
|
||||
for c in relevant:
|
||||
print(f' {c}')
|
||||
Reference in New Issue
Block a user