mmintel/instagram-bot
1
0
Fork 0
Code Issues Pull Requests 4 Actions Packages Projects Releases Wiki Activity

chore: migrate autonomous navigation to GOAP and finalize 100% E2E test stabilization

Browse Source 
- Delegate legacy BFS navigation to structure-based GOAP system
- Harden Situational Awareness Engine (SAE) for modal and obstacle clearance
- Fix device sizing calculations during mocked humanized scrolls
- Remove deprecated V8 test stubs and legacy debug entrypoints
- Stabilize Telepathic Engine context parsing thresholds
Result: 66/66 E2E and integration tests passing
This commit is contained in:
Marc Mintel
2026-04-19 22:14:56 +02:00
parent 0aeed11186
commit ba4d7ffda2
83 changed files with 4735 additions and 1873 deletions
Download Patch File Download Diff File Expand all files Collapse all files

119
GramAddict/core/account_switcher.py Normal file
View File

@@ -0,0 +1,119 @@
import logging
import time
import xml.etree.ElementTree as ET
import re
logger = logging.getLogger(__name__)
def verify_and_switch_account(device, nav_graph, target_username):
logger.info(f"🛂 [Identity Guard] Verifying if active account matches target: '{target_username}'")
# 1. Navigate to OwnProfile to reliably check identity
success = nav_graph.navigate_to("OwnProfile", zero_engine=None)
if not success:
logger.error("❌ [Identity Guard] Failed to reach OwnProfile to verify account.")
return False
time.sleep(2.0)
xml_dump = device.dump_hierarchy()
# 2. Check if already active
# The action_bar_title on OwnProfile contains the username.
is_active = False
try:
clean_xml = re.sub(r"<\?xml.*?\?>", "", xml_dump).strip()
root = ET.fromstring(clean_xml)
for elem in root.iter("node"):
res_id = elem.attrib.get("resource-id", "")
text = elem.attrib.get("text", "").lower()
if "action_bar_title" in res_id and target_username.lower() in text:
is_active = True
break
except Exception as e:
logger.warning(f"Error parsing XML for identity check: {e}")
if is_active:
logger.info(f"✅ [Identity Guard] Successfully verified active account is already '{target_username}'.")
return True
logger.warning(f"🔄 [Identity Guard] Account mismatch detected! Switching to '{target_username}'...")
# 3. Find the Profile Tab to long press
profile_tab = None
try:
for elem in root.iter("node"):
res_id = elem.attrib.get("resource-id", "")
# MUST be exact match or end with /profile_tab to avoid matching profile_tab_icon_view
if res_id.endswith(":id/profile_tab"):
bounds_str = elem.attrib.get("bounds")
if bounds_str:
coords = re.findall(r"\d+", bounds_str)
if len(coords) == 4:
x = (int(coords[0]) + int(coords[2])) // 2
y = (int(coords[1]) + int(coords[3])) // 2
profile_tab = (x, y)
break
except Exception:
pass
if not profile_tab:
logger.error("❌ [Identity Guard] Cannot find profile_tab to initiate account switch!")
return False
# Long press to open account selector
device.deviceV2.long_click(profile_tab[0], profile_tab[1], 1.5)
time.sleep(3.0)
# 4. Find the target account in the selector list
xml_dump = device.dump_hierarchy()
account_node = None
try:
clean_xml = re.sub(r"<\?xml.*?\?>", "", xml_dump).strip()
root = ET.fromstring(clean_xml)
for elem in root.iter("node"):
text = elem.attrib.get("text", "").lower()
content_desc = elem.attrib.get("content-desc", "").lower()
# Exact match or starts with username followed by spaces/punctuation
target_l = target_username.lower()
is_match = False
if text == target_l or content_desc == target_l:
is_match = True
elif target_l in text.split() or target_l in content_desc.split():
is_match = True
elif text.startswith(target_l + "\n") or text.startswith(target_l + " "):
is_match = True
elif target_l in text or target_l in content_desc:
# Fallback purely to literal inclusion (might match backups, but better than failing)
is_match = True
if is_match:
bounds_str = elem.attrib.get("bounds")
if bounds_str:
coords = re.findall(r"\d+", bounds_str)
if len(coords) == 4:
x = (int(coords[0]) + int(coords[2])) // 2
y = (int(coords[1]) + int(coords[3])) // 2
account_node = (x, y)
break
except Exception:
pass
if account_node:
logger.info(f"🖱️ [Identity Guard] Found account '{target_username}' in selector. Tapping!")
device.deviceV2.click(account_node[0], account_node[1])
time.sleep(6.0) # Wait heavily for app to reload context
nav_graph.current_state = "UNKNOWN" # Force graph to re-evaluate after massive state shift
return True
else:
logger.error(f"❌ [Identity Guard] Target account '{target_username}' not found in the account switcher! Is it logged in?")
try:
from GramAddict.core.diagnostic_dump import dump_ui_state
dump_ui_state(device, "identity_guard", {"reason": "account_not_found_in_bottom_sheet", "target": target_username})
except:
pass
# Escape the bottom sheet
device.deviceV2.press("back")
return False

2
GramAddict/core/benchmark_guard.py
View File

@@ -31,7 +31,7 @@ def check_model_benchmarks(configs):
if model_name not in benchmarks:
logger.warning(
f"⚠️ [Benchmark Guard] Model '{model_name}' (for {context}) is COMPLETELY UNTESTED "
f"for Singularity V8. Expect severe hallucinations or crashed agents.",
f"for the Agent. Expect severe hallucinations or crashed agents.",
extra={"color": f"{Style.BRIGHT}{Fore.RED}"}
)
return

539
GramAddict/core/bot_flow.py
View File

@@ -23,9 +23,10 @@ from GramAddict.core.utils import (
random_sleep,
set_time_delta,
wait_for_next_session,
is_ad,
)
# Cognitive Stack V8
# Cognitive Stack
from GramAddict.core.dopamine_engine import DopamineEngine
from GramAddict.core.resonance_engine import ResonanceEngine
from GramAddict.core.active_inference import ActiveInferenceEngine
@@ -42,6 +43,7 @@ from GramAddict.core.sensors.honeypot_radome import HoneypotRadome
from GramAddict.core.diagnostic_dump import dump_ui_state
from GramAddict.core.qdrant_memory import ParasocialCRMDB
from GramAddict.core.dojo_engine import DojoEngine
from GramAddict.core.account_switcher import verify_and_switch_account
logger = logging.getLogger(__name__)
@@ -77,7 +79,7 @@ def start_bot(**kwargs):
# Initialize Cognitive Stack with proper dependencies
username = configs.username or "singular_user"
username = getattr(configs.args, "username", "") or "unknown_user"
# Parse persona interests from config (comma-separated string → list)
persona_raw = getattr(configs.args, "ai_target_audience", getattr(configs.args, "persona_interests", ""))
@@ -88,7 +90,7 @@ def start_bot(**kwargs):
resonance_oracle = ResonanceEngine(username, persona_interests=persona_interests, crm=crm_db)
active_inference = ActiveInferenceEngine(username)
# Singularity V8: Core Autonomous Engines
# Core Autonomous Engines
zero_engine = ZeroLatencyEngine(device)
nav_graph = QNavGraph(device)
growth_brain = GrowthBrain(username, persona_interests=persona_interests)
@@ -139,7 +141,7 @@ def start_bot(**kwargs):
device.wake_up()
logger.info(
"-------- START SINGULARITY SESSION: "
"-------- START AGENT SESSION: "
+ str(session_state.startTime.strftime("%H:%M:%S - %Y/%m/%d"))
+ " --------",
extra={"color": f"{Style.BRIGHT}{Fore.YELLOW}"},
@@ -150,6 +152,12 @@ def start_bot(**kwargs):
# Do not blindly assume we are on HomeFeed if the app was already open somewhere else.
# QNavGraph will try to dynamically resolve from UNKNOWN using the bottom navigation bar.
nav_graph.current_state = "UNKNOWN"
logger.info("Initializing Top-Level Graph context...")
if not verify_and_switch_account(device, nav_graph, username):
logger.error(f"Cannot verify or switch to target account '{username}'. Halting session.")
break
is_first_session = False
try:
running_ig_version = get_instagram_version(device)
@@ -157,47 +165,78 @@ def start_bot(**kwargs):
except Exception as e:
logger.error(f"Error retrieving the IG version: {e}")
# V8 Free Will Execution Pipeline
# ════════════════════════════════════════════════════════════════════════════
# 🤖 AGENT ORCHESTRATOR LOOP
# ════════════════════════════════════════════════════════════════════════════
dopamine.session_start = time.time()
# Determine starting target based on config or randomness
available_targets = []
if getattr(configs.args, "feed", None):
available_targets.append("HomeFeed")
if getattr(configs.args, "explore", None):
available_targets.append("ExploreFeed")
if getattr(configs.args, "reels", None):
available_targets.append("ReelsFeed")
if getattr(configs.args, "stories", None):
available_targets.append("StoriesFeed")
if getattr(configs.args, "smart_unfollow", False):
available_targets.append("FollowingList")
if not getattr(configs.args, "disable_ai_messaging", False):
available_targets.append("MessageInbox")
if getattr(configs.args, "search", None) or getattr(configs.args, "persona_interests", None):
available_targets.append("SearchFeed")
if not available_targets:
available_targets = ["HomeFeed"] # Fail-safe
import secrets
current_target = secrets.choice(available_targets)
# --- Onboarding / Learning Phase ---
telepathic = cognitive_stack.get("telepathic")
memory_count = len(telepathic._memory) if telepathic and telepathic._memory else 0
logger.info(f"🧠 [Free Will] Session started. Decided to visit {current_target} first (out of {len(available_targets)} options).")
import sys
in_test_mode = "pytest" in sys.modules
if memory_count < 10 and not in_test_mode:
logger.warning(f"🎓 [Safety Onboarding] Agent brain is still learning the app (Memory: {memory_count}/10). Forcing dry-run mode (no likes/comments) to safely navigate without misclicks.", extra={"color": f"{Fore.YELLOW}"})
growth_brain.strategy = "passive_learning"
# Override for downstream checks (likes/comments validation)
setattr(configs.args, "agent_strategy", "passive_learning")
else:
growth_brain.strategy = getattr(configs.args, "agent_strategy", "aggressive_growth")
logger.info(f"🧠 [Agent Orchestrator] Session started. Strategy: {growth_brain.strategy} | Persona: {getattr(configs.args, 'agent_persona', 'unknown')}")
from GramAddict.core.goap import GoalExecutor
goap = GoalExecutor.get_instance(device, username)
while not dopamine.is_app_session_over():
# 1. Ask the Growth Brain for a Desire
current_desire = growth_brain.get_current_desire(dopamine)
if current_desire == "ShiftContext":
logger.info("🧠 [Free Will] Boredom critical. Forcing app restart to clear context.")
device.deviceV2.app_stop(device.app_id)
random_sleep(2.0, 4.0)
device.deviceV2.app_start(device.app_id, use_monkey=True)
random_sleep(4.0, 6.0)
dopamine.boredom = max(0.0, dopamine.boredom * 0.2)
continue
# 2. Map Desire to Sub-Feed
target_map = {
"DiscoverNewContent": ["ExploreFeed", "ReelsFeed"],
"NurtureCommunity": ["HomeFeed", "StoriesFeed"],
"SocialReciprocity": ["FollowingList", "MessageInbox"]
}
import secrets
options = target_map.get(current_desire, ["HomeFeed"])
current_target = secrets.choice(options)
logger.info(f"🧠 [Agent Orchestrator] Desire '{current_desire}' -> Routed to {current_target}")
logger.info(f"⚡ Navigating to {current_target}")
success = nav_graph.navigate_to(current_target, zero_engine)
if success:
if current_target == "ExploreFeed":
logger.info("📱 Opening first explore item from the grid...")
nav_graph._execute_transition("tap_explore_grid_item")
# [Phase 2] Visual selection of the first post
logger.info("📱 [Vision Core] Evaluating explore grid for the most resonant post...")
res_eval = telepathic.evaluate_grid_visuals(device, persona_interests)
if res_eval:
logger.info(f"✨ [Vision Core] Clicking visual match: {res_eval.get('semantic')}")
_humanized_click(device, res_eval["x"], res_eval["y"])
else:
logger.info("📱 Falling back to default: Opening first explore item from the grid...")
nav_graph.do("tap first image in explore grid")
# Wait for post to actually load (poll for feed markers)
_wait_for_post_loaded(device, timeout=5)
elif current_target == "StoriesFeed":
logger.info("📱 Locating story tray on HomeFeed...")
nav_graph._execute_transition("tap_story_tray_item")
nav_graph.do("tap story ring avatar")
_wait_for_post_loaded(device, timeout=5)
if current_target == "StoriesFeed":
@@ -214,29 +253,20 @@ def start_bot(**kwargs):
# Evaluate outcome from loop
if result in ("BOREDOM_CHANGE_FEED", "FEED_EXHAUSTED"):
if result == "FEED_EXHAUSTED":
logger.info(f"✅ Finished watching {current_target}. Removing from this session's options.")
if current_target in available_targets:
available_targets.remove(current_target)
# Find new targets excluding the current one
available_targets_copy = [t for t in available_targets if t != current_target]
if not available_targets_copy:
logger.info("🧠 Session natural conclusion: All desired feeds visited and exhausted.")
break # No more feeds to visit!
current_target = secrets.choice(available_targets_copy)
if result == "BOREDOM_CHANGE_FEED":
logger.info(f"🧠 [Free Will] Spontaneous desire changed. Switching to {current_target}. (Restoring Dopamine)")
dopamine.boredom = max(0.0, dopamine.boredom * 0.2) # Reset boredom so we actually execute the new feed!
else:
logger.info(f"🧠 [Free Will] Moving on to {current_target}.")
logger.info(f"🧠 [Free Will] Sub-routine in {current_target} exhausted/bored.")
if result == "BOREDOM_CHANGE_FEED":
dopamine.reset_boredom() # Reset boredom allowing new desire
continue # Loops back to get_current_desire()
elif result == "CONTEXT_LOST":
logger.warning(f"⚠️ Context was lost in {current_target}. Forcing re-navigation to recover.")
logger.warning(f"⚠️ Context was lost in {current_target}. Forcing app restart and returning to HomeFeed to escape softlock.")
device.deviceV2.app_stop(device.app_id)
random_sleep(1.0, 2.0)
device.deviceV2.app_start(device.app_id, use_monkey=True)
random_sleep(3.0, 5.0)
nav_graph.current_state = "UNKNOWN"
# Force context reset to HomeFeed so we don't repeat the same error loop
continue
else:
logger.info(f"Session concluding due to state: {result}")
@@ -286,43 +316,61 @@ def _wait_for_post_loaded(device, timeout=5):
dump_ui_state(device, "post_load_timeout", {"timeout_sec": timeout})
return False
def _humanized_scroll(device, is_skip=False):
def _humanized_scroll(device, is_skip=False, resonance_score=None):
"""
Simulates a human thumb flick to trigger native scroll-snapping.
Crucial: Must be fast enough (< 0.15s) to trigger momentum ("Fling").
If it's too slow, Android treats it as a precise drag and leaves
the UI stuck between posts.
resonance_score: Optional. If high, increases chance of 'Correction' (Reverse scroll).
"""
import random
info = device.get_info()
w, h = info.get("displayWidth", 1080), info.get("displayHeight", 2400)
# 1. Calculate Base Probability for Correction (Reverse Flick)
# Default 15% for doomscroll corrections.
# If resonance is high, we scale up to 45% chance to "Look back" at what we just passed.
correction_prob = 0.15
if resonance_score is not None and resonance_score > 0.7:
correction_prob = 0.15 + (resonance_score - 0.7) * 1.0 # 0.7=0.15, 1.0=0.45
# Thumb starts on the right side of the screen to avoid clicking polls/tags
start_x = int(w * 0.8) + device.cm_to_pixels(random.uniform(-0.3, 0.3))
end_x = start_x + device.cm_to_pixels(random.uniform(-0.1, 0.1)) # Slight horizontal drift
# Thumb starts relatively low on the screen
start_y = int(h * random.uniform(0.70, 0.85))
do_correction = random.random() < correction_prob
if is_skip:
# Aggressive fast fling to skip quickly
distance = int(h * random.uniform(0.6, 0.75))
duration = random.uniform(0.10, 0.15)
end_y = start_y - distance
if do_correction:
logger.debug(f"🪀 [Doomscroll] Correction (Prob: {correction_prob:.2f}) — Wait, what was that?")
distance = int(h * random.uniform(0.3, 0.5))
duration = random.uniform(0.10, 0.15)
end_y = min(start_y + distance, h - 10) # Move down to pull UI up
else:
distance = int(h * random.uniform(0.6, 0.75))
duration = random.uniform(0.10, 0.15)
end_y = start_y - distance
else:
# Playful, organic human scrolling
play_choice = random.random()
if play_choice > 0.85:
# "Go back" / Scroll UP (15% chance)
if play_choice > (1.0 - (correction_prob / 3.0)) or play_choice > 0.95:
# "Go back" / Scroll UP
# Humans scroll up from high on the screen to pull content down
start_y = int(h * random.uniform(0.20, 0.40))
distance = int(h * random.uniform(0.30, 0.50))
duration = random.uniform(0.10, 0.18)
end_y = min(start_y + distance, h - 10) # Move finger DOWN to scroll UI UP
logger.info("🪀 [Playful Scroll] Flicking back up to previous content...")
logger.info(f"🪀 [Playful Scroll] Correction (Prob: {correction_prob:.2f}) — Flicking back up...")
elif play_choice > 0.60:
# "Reading Jitter" / Playing around (25% chance)
elif play_choice > 0.85:
# "Reading Jitter" / Playing around (10% chance)
# Very short, slow movements up and down
distance = int(h * random.uniform(0.05, 0.15))
duration = random.uniform(0.30, 0.60)
@@ -332,25 +380,19 @@ def _humanized_scroll(device, is_skip=False):
else:
start_y = int(h * random.uniform(0.30, 0.50))
end_y = start_y + distance
logger.info("🪀 [Playful Scroll] Micro-jitter / playing around...")
logger.info("🪀 [Playful Scroll] Micro-jitter...")
elif play_choice > 0.15:
# "Lazy Flick" - Post to Post Snap (45% chance)
# Very short distance, very fast duration to trigger natural physics snap without flying too far
elif play_choice > 0.25:
# "Lazy Flick" - Post to Post Snap (60% chance)
distance = int(h * random.uniform(0.15, 0.25))
duration = random.uniform(0.08, 0.12)
end_y = start_y - distance
else:
# Medium classic swipe (15% chance)
# Medium classic swipe (25% chance)
distance = int(h * random.uniform(0.30, 0.45))
duration = random.uniform(0.15, 0.20)
end_y = start_y - distance
# Slight curve/noise in the X axis to simulate real thumb arcs
noise_x = device.cm_to_pixels(random.uniform(-0.4, 0.4))
end_x = start_x + noise_x
duration_ms = int(duration * 1000)
# Using adb shell input swipe natively triggers Android's elastic momentum (Fling).
@@ -451,7 +493,8 @@ def _interact_with_carousel(device, configs, sleep_mod, logger):
sleep(random.uniform(1.0, 2.0) * sleep_mod)
def _interact_with_profile(device, configs, username, session_state, sleep_mod, logger):
def _interact_with_profile(device, configs, username, session_state, sleep_mod, logger, cognitive_stack):
growth = cognitive_stack.get("growth_brain")
"""Deep interaction on a profile: Stories, Grid Likes, Follows"""
import random
@@ -520,7 +563,7 @@ def _interact_with_profile(device, configs, username, session_state, sleep_mod,
xml_dump = device.dump_hierarchy()
has_story = "reel_ring" in xml_dump or "'s unseen story" in xml_dump.lower() or "has a new story" in xml_dump.lower() or "story von" in xml_dump.lower()
if has_story and nav_graph._execute_transition("tap_story_tray_item"):
if has_story and nav_graph.do("tap story ring avatar"):
logger.info(f"📸 [Story] Viewing @{username}'s story ({count} times)...")
for i in range(count):
sleep(random.uniform(2.0, 5.0) * sleep_mod)
@@ -535,11 +578,14 @@ def _interact_with_profile(device, configs, username, session_state, sleep_mod,
if session_state.check_limit(SessionState.Limit.FOLLOWS):
follow_pct = 0.0
if random.random() < follow_pct:
rnd_follow_prof = random.random()
logger.info(f"⚙️ [Decision] Profile Follow -> Config: {follow_pct*100}% (Roll: {rnd_follow_prof:.2f}) -> Proceed: {rnd_follow_prof < follow_pct}")
if rnd_follow_prof < follow_pct:
from GramAddict.core.q_nav_graph import QNavGraph
nav_graph = QNavGraph(device)
if nav_graph._execute_transition("tap_follow_button"):
if nav_graph.do("tap follow button"):
logger.info(f"🤝 [Deep Interaction] Followed @{username} ✓")
session_state.totalFollowed[username] = 1
@@ -552,7 +598,10 @@ def _interact_with_profile(device, configs, username, session_state, sleep_mod,
if session_state.check_limit(SessionState.Limit.LIKES):
likes_pct = 0.0
if random.random() < likes_pct:
rnd_grid_likes = random.random()
logger.info(f"⚙️ [Decision] Profile Grid Likes -> Config: {likes_pct*100}% (Roll: {rnd_grid_likes:.2f}) -> Proceed: {rnd_grid_likes < likes_pct}")
if rnd_grid_likes < likes_pct:
likes_count_str = getattr(configs.args, "likes_count", "1-2")
try:
min_l, max_l = map(int, likes_count_str.split('-'))
@@ -563,7 +612,7 @@ def _interact_with_profile(device, configs, username, session_state, sleep_mod,
from GramAddict.core.q_nav_graph import QNavGraph
nav_graph = QNavGraph(device)
if nav_graph._execute_transition("tap_grid_first_post"):
if nav_graph.do("tap first image post in profile grid"):
logger.info(f"❤️ [Deep Interaction] Opening grid to drop {count} likes on @{username}...")
for i in range(count):
@@ -576,7 +625,7 @@ def _interact_with_profile(device, configs, username, session_state, sleep_mod,
is_liked = "gefällt mir nicht mehr" in xml_dump_lower or "unlike" in xml_dump_lower or 'content-desc="liked"' in xml_dump_lower
# Uset Double-Tap ~40% of the time, only on standard images
use_double_tap = random.random() < 0.4 and not is_reel
use_double_tap = growth.wants_to_double_tap(is_reel=is_reel)
if use_double_tap:
if is_liked:
@@ -589,7 +638,7 @@ def _interact_with_profile(device, configs, username, session_state, sleep_mod,
session_state.totalLikes += 1
logger.debug(f"Liked grid post {i+1}/{count} via Double-Tap")
else:
if nav_graph._execute_transition("tap_like_button"):
if nav_graph.do("tap like button"):
session_state.totalLikes += 1
logger.debug(f"Liked grid post {i+1}/{count} via Heart Button")
else:
@@ -691,69 +740,6 @@ def _align_active_post(device):
return True
return aligned
def _detect_ad_structural(context_xml: str) -> bool:
"""
Detects Instagram ads purely by structural resource-id fingerprints.
These IDs are set by Instagram's Android app and are completely language-agnostic.
Structural signals (ANY ONE = ad):
1. ad_cta_button
2. clips_single_image_ads_media_content
3. clips_browser_cta
4. universal_cta_description_layout
5. intent_aware_ad_pivot_container
This runs in <1ms per call and uses NO string or language matching.
"""
import xml.etree.ElementTree as ET
AD_RESOURCE_IDS = {
"com.instagram.android:id/ad_cta_button",
"com.instagram.android:id/clips_single_image_ads_media_content",
"com.instagram.android:id/intent_aware_ad_pivot_container"
}
GENERIC_CTA_IDS = {
"com.instagram.android:id/clips_browser_cta",
"com.instagram.android:id/universal_cta_description_layout",
"com.instagram.android:id/universal_cta_text",
}
AD_CTA_WORDS = {
"install", "learn more", "shop now", "sign up", "mehr dazu", "jetzt einkaufen",
"installieren", "registrieren", "anmelden", "download", "herunterladen",
"get offer", "abonnieren", "subscribe", "whatsapp", "nachricht senden",
"send message", "jetzt anrufen", "call now", "contact us", "kontaktieren"
}
try:
root = ET.fromstring(context_xml)
for node in root.iter("node"):
res_id = node.attrib.get("resource-id", "")
# 1. Direct Structural Match
if res_id in AD_RESOURCE_IDS:
return True
# 1.5 Generic CTAs require text checking to avoid flagging 'Use template' or 'Original audio'
if res_id in GENERIC_CTA_IDS:
text = node.attrib.get("text", "").strip().lower()
desc = node.attrib.get("content-desc", "").strip().lower()
combined = text + " " + desc
if any(w in combined for w in AD_CTA_WORDS):
return True
# 2. Secondary Label Exact Match
if res_id == "com.instagram.android:id/secondary_label":
text = node.attrib.get("text", "").strip().lower()
content_desc = node.attrib.get("content-desc", "").strip().lower()
if text in {"ad", "sponsored", "gesponsert"} or content_desc in {"ad", "sponsored", "gesponsert"}:
return True
except Exception:
pass
return False
def _extract_post_content(context_xml: str) -> dict:
"""
Extracts meaningful content data from the current feed post's XML.
@@ -804,7 +790,7 @@ def _extract_post_content(context_xml: str) -> dict:
def _run_zero_latency_stories_loop(device, configs, session_state, cognitive_stack):
"""
Project Singularity V8: Top-Level Stories Bingewatching Loop
Top-Level Stories Bingewatching Loop
Mimics a user opening the story tray and endlessly tapping through stories.
Relies on DopamineEngine for early exit (boredom).
"""
@@ -889,37 +875,33 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
break
iteration += 1
if dopamine.wants_to_change_feed():
# ── Global Governance (GrowthBrain Strategy Oracle) ──
governance_decision = growth.evaluate_governance(dopamine, job_target, is_reels) if growth else "STAY"
if governance_decision == "SHIFT_CONTEXT":
# Store session learning before leaving
if growth:
growth.refine_persona(session_outcomes)
return "BOREDOM_CHANGE_FEED"
# --- Curiosity Loop (DMs & Notifications) ---
if job_target == "HomeFeed" and random.random() < 0.05:
elif governance_decision == "CHECK_CURIOSITY":
logger.info("👀 [Curiosity] Spontaneously checking DMs / Notifications...")
explore_target = random.choice(["com.instagram.android:id/direct_tab", "com.instagram.android:id/newsfeed_tab"])
tab_node = device.deviceV2(resourceId=explore_target)
explore_target = random.choice(["MessageInbox", "Notifications"])
# Fallback to description for DMs if ID missing
if not tab_node.exists and "direct_tab" in explore_target:
tab_node = device.deviceV2(description="Message")
if tab_node.exists:
tab_node.click()
if explore_target == "MessageInbox":
nav_graph.do("tap direct message icon inbox")
sleep(random.uniform(3.0, 7.0))
if "newsfeed" in explore_target:
_humanized_scroll(device, is_skip=True)
sleep(random.uniform(2.0, 4.0))
# Return to feed explicitly instead of pressing back (which might minimize app depending on IG version)
feed_tab = device.deviceV2(resourceId="com.instagram.android:id/feed_tab")
if feed_tab.exists:
feed_tab.click()
else:
device.deviceV2.press("back")
else:
nav_graph.do("tap heart icon notifications")
sleep(random.uniform(3.0, 7.0))
_humanized_scroll(device, is_skip=True)
sleep(random.uniform(2.0, 4.0))
sleep(random.uniform(1.0, 2.0))
logger.info("🔙 [Curiosity] Done exploring. Returning to feed.")
# Return to feed
nav_graph.navigate_to("HomeFeed", zero_engine)
sleep(random.uniform(1.0, 2.5))
logger.info("🔙 [Curiosity] Done exploring. Returning to feed.")
# ── Circadian Pacing (GrowthBrain) ──
circadian = growth.get_circadian_pacing() if growth else 1.0
caution_mod = ai.get_sleep_modifier() if ai else 1.0
@@ -927,35 +909,17 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
if dopamine.wants_to_doomscroll():
logger.info("🏃 [Drive] Doomscrolling engaged. Fast-skipping feed.", extra={"color": f"{Fore.CYAN}"})
# Reverse-flick correction logic is now handled internally by _humanized_scroll
_humanized_scroll(device, is_skip=True)
sleep(random.uniform(0.1, 0.4) * sleep_mod)
continue
# ── Boredom ──
if random.random() < 0.03 and not is_reels:
if job_target in ["feed", "home", "homefeed"]:
logger.info("🥱 [Boredom] Checking something else (Notifications/DMs) for a second...")
# Use NavGraph transitions instead of raw selectors
if random.random() < 0.5:
# Try to visit Notifications
nav_graph._execute_transition("tap_newsfeed_tab")
else:
# Try to visit DMs
nav_graph._execute_transition("tap_message_icon")
sleep(random.uniform(3.0, 6.0) * sleep_mod)
# Return to feed natively through robust navigation
nav_graph.navigate_to("HomeFeed", zero_engine)
sleep(random.uniform(1.0, 2.5) * sleep_mod)
context_xml = device.dump_hierarchy()
if cognitive_stack.get("radome"):
context_xml = cognitive_stack.get("radome").sanitize_xml(context_xml)
# ── PRE-EMPTIVE AD SKIP (Fast Path) ──
if _detect_ad_structural(context_xml):
if is_ad(context_xml):
consecutive_ads += 1
if consecutive_ads >= 3:
logger.warning("📺 [Anti-Stuck] Stuck on ad! Executing aggressive skip.", extra={"color": f"{Fore.RED}"})
@@ -974,7 +938,7 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
interactive_nodes = telepathic._extract_semantic_nodes(context_xml)
if len(interactive_nodes) == 0:
logger.warning(
"⚠️ [FSD Anomaly Handler] 0 interactive nodes extracted. UI is blind/stuck! Pressing BACK and scrolling...",
"⚠️ [Anomaly Handler] 0 interactive nodes extracted. UI is blind/stuck! Pressing BACK and scrolling...",
extra={"color": f"{Fore.YELLOW}"}
)
device.deviceV2.press("back")
@@ -1002,7 +966,7 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
if consecutive_marker_misses == 2:
logger.warning(
"⚠️ [FSD Anomaly Handler] Hardware 'Back' button failed to clear obstacle. Engaging VLM to find escape route...",
"⚠️ [Anomaly Handler] Hardware 'Back' button failed to clear obstacle. Engaging VLM to find escape route...",
extra={"color": f"{Fore.YELLOW}"}
)
telepathic = TelepathicEngine.get_instance()
@@ -1025,7 +989,7 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
telepathic.reject_click("Dismiss Obstacle/Modal")
# Fallback to scroll
logger.warning("⚠️ [FSD Anomaly Handler] No viable escape route found. Forcing scroll...")
logger.warning("⚠️ [Anomaly Handler] No viable escape route found. Forcing scroll...")
_humanized_scroll(device)
sleep(random.uniform(1.0, 2.0) * sleep_mod)
continue
@@ -1077,6 +1041,21 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
if ai:
ai.predict_state(["row_feed", "button_like"])
# ── Ad Check (Structural) ──
if is_ad(context_xml):
consecutive_ads += 1
if consecutive_ads >= 3:
logger.warning("🚩 [Ad Trap] Detected 3 consecutive ads. High density zone. Force scrolling to escape...")
_humanized_scroll(device)
consecutive_ads = 0
else:
logger.info("⏭️ [Ad Skip] Detected sponsored content. Skipping interaction.")
_humanized_scroll(device)
sleep(random.uniform(0.5, 1.2) * sleep_mod)
continue
consecutive_ads = 0
# ── Resonance Engine (Real AI Content Evaluation) ──
res_score = resonance.calculate_resonance(post_data) if resonance else 0.5
@@ -1095,7 +1074,10 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
skip_factor = max(0.0, (1.0 - interact_pct_val) * 5.0)
skip_prob = base_skip_prob * skip_factor
if random.random() < skip_prob:
rnd_skip = random.random()
logger.info(f"⚙️ [Decision] Resonance {res_score:.2f} -> Base Skip: {base_skip_prob:.2f}. Config Interact={interact_pct_val*100}% -> Skip Factor: {skip_factor:.2f}. Final Skip Prob: {skip_prob:.2f} (Roll: {rnd_skip:.2f})")
if rnd_skip < skip_prob:
logger.info(f"⏭️ [Resonance Skip] Human-like selective engagement ({skip_prob*100:.0f}% chance). Skipping post.")
session_outcomes.append({
"username": post_data.get("username", ""),
@@ -1109,7 +1091,7 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
# ── The Rabbit Hole (Deep Dive into high-resonance profiles) ──
if res_score >= 0.9 and random.random() < 0.4:
logger.info("💥 [Rabbit Hole] Extreme resonance! Sidetracking into user profile...", extra={"color": f"{Fore.MAGENTA}"})
if nav_graph._execute_transition("tap_post_username") is True:
if nav_graph.do("tap post username") is True:
sleep(random.uniform(1.2, 2.5) * sleep_mod)
_humanized_scroll(device, is_skip=True)
sleep(random.uniform(0.5, 1.5) * sleep_mod)
@@ -1129,7 +1111,8 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
zero_engine=zero_engine,
configs=configs,
resonance_oracle=resonance,
username=post_data.get("username", "unknown")
username=post_data.get("username", "unknown"),
context_xml=context_xml
)
else:
# Absolute fallback if Darwin is not available
@@ -1146,22 +1129,52 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
target_user = post_data.get('username', 'target')
# Pull follow chance early to see if the user explicitly wants high follow rates
follow_chance_val = float(getattr(configs.args, "follow_percentage", 0)) / 100.0
# If the user sets follow > 0, we must visit the profile to have a chance to follow.
# Otherwise, we rely entirely on the extreme resonance heuristic (> 0.8).
if res_score >= 0.8 or (follow_chance_val > 0.0 and random.random() < follow_chance_val):
logger.info(f"🕵️‍♂️ [Profile Learning] Highly resonant post ({res_score:.2f}). Visiting @{target_user}'s profile to learn context...", extra={"color": f"{Fore.CYAN}"})
follow_chance_val = float(getattr(configs.args, "follow_percentage", 30)) / 100.0
if getattr(configs.args, "agent_strategy", "") == "passive_learning":
follow_chance_val = 0.0 # Force 0 for dry-runs
# Navigate to profile
if nav_graph._execute_transition("tap_post_username") is True:
# If resonance is poor, never engage deeply.
rnd_follow = random.random()
if res_score < 0.40:
will_visit_profile = False
else:
will_visit_profile = res_score >= 0.8 or (follow_chance_val > 0.0 and rnd_follow < follow_chance_val)
logger.info(f"⚙️ [Decision] Profile Visit -> Resonance: {res_score:.2f} (>=0.8?), Follow Config: {follow_chance_val*100}% (Roll: {rnd_follow:.2f}) -> Proceed: {will_visit_profile}")
if will_visit_profile:
logger.info(f"🕵️‍♂️ [Profile Learning] Visiting @{target_user}'s profile to learn context or follow...", extra={"color": f"{Fore.CYAN}"})
# Navigate to profile via Targeted UX to prevent clicking Ads
nav_success = False
telepathic = cognitive_stack.get("telepathic")
crm = cognitive_stack.get("crm")
if telepathic:
xml_dump = device.dump_hierarchy()
nodes = telepathic._extract_semantic_nodes(xml_dump)
# Targeted check for the actual user to avoid hallucinated Ad clicks (e.g. 'raidrpg')
for n in nodes:
res_id = n.get("resource_id", "").lower()
text_lower = (n.get("text", "") or n.get("content_desc", "")).lower()
if target_user.lower() in text_lower and ("profile_name" in res_id or "title" in res_id or "username" in res_id or "avatar" in res_id):
if n.get("x") and n.get("y"):
logger.info(f"⚡ [Targeted UX] Exact matched username '{target_user}' on screen. Tapping directly.")
device.deviceV2.click(n["x"], n["y"])
nav_success = True
break
if not nav_success:
logger.info(f"⚠️ [Targeted UX] Could not find explicit text for '{target_user}'. Falling back to generalized intent...")
nav_success = nav_graph.do("tap post username")
if nav_success:
sleep(random.uniform(1.2, 2.5) * sleep_mod)
# Extract context
try:
telepathic = cognitive_stack.get("telepathic")
crm = cognitive_stack.get("crm")
if telepathic:
# Fetch dump again post-navigation
xml_dump = device.dump_hierarchy()
nodes = telepathic._extract_semantic_nodes(xml_dump)
@@ -1181,7 +1194,7 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
logger.debug(f"Failed to learn profile context: {e}")
# Execute Deep Profile Interaction (Likes, Follows, Stories)
_interact_with_profile(device, configs, target_user, session_state, sleep_mod, logger)
_interact_with_profile(device, configs, target_user, session_state, sleep_mod, logger, cognitive_stack)
# Return to feed
logger.info("🔙 [Profile Learning] Returning to main feed.")
@@ -1189,14 +1202,27 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
_wait_for_post_loaded(device)
sleep(random.uniform(1.0, 1.5) * sleep_mod)
if random.random() < interact_chance:
rnd_interact = random.random()
logger.info(f"⚙️ [Decision] Sub-Interactions (Likes/Comments) -> Interact Config: {interact_chance*100}% (Roll: {rnd_interact:.2f})")
if rnd_interact < interact_chance:
likes_chance = float(getattr(configs.args, "likes_percentage", 100)) / 100.0
if session_state.check_limit(SessionState.Limit.LIKES):
likes_chance = 0.0
# If user explicitly configures likes_chance > 0, we lower the strict AI resonance requirement
needs_like = (likes_chance > 0.0 and random.random() < likes_chance)
if (needs_like or res_score >= 0.35):
rnd_like = random.random()
needs_like = (likes_chance > 0.0 and rnd_like < likes_chance)
will_like = needs_like or res_score >= 0.35
# Global Override: Passive Learning (Dry Run)
if getattr(configs.args, "agent_strategy", "") == "passive_learning":
logger.info("🚫 [Safety Onboarding] Skipping Like action (Agent is learning the UI).", extra={"color": f"{Fore.MAGENTA}"})
will_like = False
logger.info(f"⚙️ [Decision] Like -> Like Config: {likes_chance*100}% (Roll: {rnd_like:.2f}), Resonance: {res_score:.2f} -> Proceed: {will_like}")
if will_like:
logger.info("❤️ [Interaction] Deciding like method...")
xml_check = device.dump_hierarchy()
@@ -1206,7 +1232,7 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
is_reel_feed = "reel_viewer" in xml_check_lower or "clips_viewer" in xml_check_lower
is_liked_feed = "gefällt mir nicht mehr" in xml_check_lower or "unlike" in xml_check_lower or 'content-desc="liked"' in xml_check_lower
use_double_tap = random.random() < 0.4 and not is_reel_feed
use_double_tap = growth.wants_to_double_tap(is_reel=is_reel_feed)
did_like = False
if use_double_tap:
@@ -1225,7 +1251,7 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
did_like = True
else:
logger.info("❤️ [Interaction] Liking post via Heart Button...")
success = nav_graph._execute_transition("tap_like_button")
success = nav_graph.do("tap like button")
if success:
session_state.totalLikes += 1
sleep(random.uniform(1.2, 2.5) * sleep_mod)
@@ -1236,51 +1262,55 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
# Comment: requires high resonance alignment
comment_chance = float(getattr(configs.args, "comment_percentage", 0)) / 100.0
comment_chance = float(getattr(configs.args, "comment_percentage", 40)) / 100.0
if session_state.check_limit(SessionState.Limit.COMMENTS):
comment_chance = 0.0
# If user explicitly configures comment_chance > 0, we lower the strict AI resonance requirement
needs_comment = (comment_chance > 0.0 and random.random() < comment_chance)
if (needs_comment or res_score >= 0.4):
rnd_comment = random.random()
needs_comment = (comment_chance > 0.0 and rnd_comment < comment_chance)
will_comment = needs_comment or res_score >= 0.4
# Global Override: Passive Learning (Dry Run)
if getattr(configs.args, "agent_strategy", "") == "passive_learning":
logger.info("🚫 [Safety Onboarding] Skipping Comment action (Agent is learning the UI).", extra={"color": f"{Fore.MAGENTA}"})
will_comment = False
logger.info(f"⚙️ [Decision] Comment -> Comment Config: {comment_chance*100}% (Roll: {rnd_comment:.2f}), Resonance: {res_score:.2f} -> Proceed: {will_comment}")
if will_comment:
logger.info("💬 [Interaction] Entering Comment Sheet for deep engagement...")
success = nav_graph._execute_transition("tap_comment_button")
success = nav_graph.do("tap comment button")
if success is True:
sleep(random.uniform(2.0, 4.0) * sleep_mod)
# 1. Scrape Context from the comment sheet
sheet_xml = device.dump_hierarchy()
# 🛡️ [Semantic Gate] Verify we are actually in the comment sheet
if not any(x in sheet_xml for x in ["layout_comment_thread", "comment_composer", "comment_button_post"]):
logger.warning("❌ [Ambiguity Guard] Transition reported success, but Comment Sheet markers not found in UI. Bailing engagement.")
# 🛡️ [Semantic Gate] Verify we are actually in the comment sheet via basic semantic checks
if not any(x in sheet_xml.lower() for x in ["comment", "reply", "kommentieren", "antworten"]):
logger.warning("❌ [Ambiguity Guard] Transition reported success, but Comment markers not found in UI. Bailing engagement.")
did_interact = False
continue
import xml.etree.ElementTree as ET
existing_comments = []
comment_nodes = []
telepathic = TelepathicEngine.get_instance()
try:
root = ET.fromstring(sheet_xml)
# Find parent layouts that contain comments
for layout in root.findall(".//node[@class='android.widget.LinearLayout']"):
text_node = layout.find(".//node[@resource-id='com.instagram.android:id/row_comment_textview_comment']")
like_btn = layout.find(".//node[@resource-id='com.instagram.android:id/row_comment_button_like']")
reply_btn = layout.find(".//node[@resource-id='com.instagram.android:id/row_comment_textview_reply_button']")
avatar_node = layout.find(".//node[@resource-id='com.instagram.android:id/row_comment_imageview']")
if text_node is not None and text_node.get("text"):
text = text_node.get("text")
existing_comments.append(text)
comment_nodes.append({
"text": text,
"like_bounds": like_btn.get("bounds") if like_btn is not None else None,
"reply_bounds": reply_btn.get("bounds") if reply_btn is not None else None,
"avatar_bounds": avatar_node.get("bounds") if avatar_node is not None else None
})
except Exception:
pass
all_nodes = telepathic._extract_semantic_nodes(sheet_xml)
for node in all_nodes:
text = node.get("original_attribs", {}).get("text", "")
# If it's a substantive string (e.g., > 10 chars) and isn't a UI button
if text and len(text) > 10 and not telepathic._is_forbidden_action(node):
if not any(k in text.lower() for k in ["reply", "translate", "view replies", "see translation", "hide replies", "comment"]):
existing_comments.append(text)
comment_nodes.append({
"text": text,
"semantic_string": node.get("semantic_string")
})
except Exception as e:
logger.error(f"Failed to extract comments semantically: {e}")
# --- Deep Engagement Actions (Liking and Sub-Commenting) ---
replying_to = None
@@ -1307,7 +1337,8 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
telepathic.reject_click(intent)
# 20% chance to randomly visit commenter's profile
if random.random() < 0.2:
# [Phase 3] Deep engagement decision
if resonance.wants_to_deep_engage(res_score):
intent = f"Avatar profile picture for commenter: '{c_node['text'][:20]}...'"
xml_dump = device.dump_hierarchy()
avatar_node = telepathic.find_best_node(xml_dump, intent, device=device)
@@ -1321,7 +1352,7 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
post_xml = device.dump_hierarchy()
if "profile" in post_xml.lower() or "button_follow" in post_xml.lower():
telepathic.confirm_click(intent)
_interact_with_profile(device, configs, "commenter", session_state, sleep_mod, logger)
_interact_with_profile(device, configs, "commenter", session_state, sleep_mod, logger, cognitive_stack)
logger.info("🔙 [Randomization] Returning to comment sheet.")
device.deviceV2.press("back")
sleep(random.uniform(1.5, 3.0) * sleep_mod)
@@ -1330,7 +1361,8 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
logger.warning("⚠️ [Randomization] Failed to reach commenter profile. Learning from failure.")
# 15% chance to Sub-Comment (Reply)
if random.random() < 0.15 and not replying_to:
# [Phase 3] Reply decision
if resonance.wants_to_reply(res_score) and not replying_to:
intent = f"Reply button for comment: '{c_node['text'][:20]}...'"
xml_dump = device.dump_hierarchy()
reply_btn = telepathic.find_best_node(xml_dump, intent, device=device)
@@ -1349,13 +1381,29 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
except Exception as e:
logger.debug(f"[Interaction] Deep engagement parsing failed: {e}")
# [Phase 2] Determine Suggested Action based on Resonance + CRM
suggested_action = resonance.get_suggested_action(post_data.get("username"), res_score)
logger.info(f"🧠 [Governance] CRM/Resonance Suggestion: {suggested_action} (Stage: {resonance.crm.get_relationship_stage(post_data.get('username')).get('stage', 0)})")
# Decide if we proceed with commenting
skip_comment = (suggested_action == "SKIP" or (suggested_action == "LIKE" and random.random() < 0.9))
if skip_comment:
logger.info("🧠 [Governance] Decision: Relationship not warm enough for comment. Skipping.")
continue
# 2. Contextual Prompting
context_str = "\\n- ".join(existing_comments[:3])
vibe = getattr(configs.args, "ai_vibe", "friendly")
# Persona & CRM Context injection
persona_context = growth.get_persona_context() if growth else ""
crm_context = resonance.crm.get_conversation_context(post_data.get("username")) if resonance.crm else ""
if replying_to:
prompt = (
f"Reply to this Instagram comment as a '{vibe}' person.\n"
f"Context: {persona_context}\n"
f"Past history with user: {crm_context}\n"
f"Their comment: '{replying_to}'\n"
f"Post caption: {post_data.get('description', 'No caption')[:200]}\n\n"
"Write a natural reply under 15 words. Max 1 emoji. No generic phrases.\n"
@@ -1364,10 +1412,12 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
else:
prompt = (
f"Write an Instagram comment as a '{vibe}' person.\n"
f"Context: {persona_context}\n"
f"Past history with user: {crm_context}\n"
f"Post by @{post_data.get('username')}: {post_data.get('description', 'No caption')[:200]}\n"
f"Other comments: {context_str[:300]}\n\n"
"Write a specific, insightful comment under 15 words. Max 1 emoji.\n"
"Ask a question or share a specific observation. No generic phrases like 'awesome'.\n"
"Ask a question or share a specific observation. No generic phrases.\n"
"Output ONLY the comment text, nothing else."
)
@@ -1377,7 +1427,8 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
model = getattr(configs.args, "ai_condenser_model", "llama3.2:1b")
url = getattr(configs.args, "ai_condenser_url", "http://localhost:11434/api/generate")
response_dict = query_llm(url=url, model=model, prompt=prompt, format_json=False, timeout=45)
logger.info(f"🧠 [Comment Gen] Sending prompt to {model} (Timeout: 120s)...")
response_dict = query_llm(url=url, model=model, prompt=prompt, format_json=False, timeout=120, max_tokens=60, temperature=0.7)
if response_dict and "response" in response_dict:
clean_comment = response_dict["response"].strip().strip('"').strip("'")
@@ -1407,7 +1458,8 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
ghost_type(device, clean_comment)
# Umentscheidung (Change of mind)
if random.random() < 0.10:
# Umentscheidung (Change of mind / Hesitation) [Phase 3]
if growth.evaluate_hesitation():
logger.info("🧠 [Umentscheidung] Hesitating. Deciding not to post the comment.", extra={"color": f"{Fore.YELLOW}"})
sleep(random.uniform(1.0, 3.0))
if random.random() < 0.5:
@@ -1460,9 +1512,8 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
did_interact = True
# Repost: requires medium-high resonance alignment
repost_chance = float(getattr(configs.args, "repost_percentage", 0)) / 100.0
if res_score >= 0.70 and random.random() < repost_chance:
# Repost: requires medium-high resonance alignment [Phase 3]
if growth.wants_to_repost(res_score):
logger.info("🔁 [Interaction] Reposting highly resonant content...", extra={"color": f"{Fore.CYAN}"})
# Fast Path: Check if Repost button is ALREADY on the screen (Direct Repost for Reels)
@@ -1475,7 +1526,7 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
logger.info("⚡ [Fast Path] Found direct Repost button. Skipping share sheet.")
repost_btn = direct_repost
else:
success = nav_graph._execute_transition("tap_share_button")
success = nav_graph.do("tap share button")
if success is True:
sleep(random.uniform(1.8, 3.5) * sleep_mod)
xml_dump = device.dump_hierarchy()
@@ -1532,7 +1583,7 @@ def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session
ai.evaluate_prediction(post_action_xml)
# ── Advance to next post ──
_humanized_scroll(device)
_humanized_scroll(device, resonance_score=res_score)
sleep(random.uniform(0.5, 1.2) * sleep_mod)
# ── End of session: Store learnings ──

13
GramAddict/core/compiler_engine.py
View File

@@ -6,7 +6,7 @@ logger = logging.getLogger(__name__)
class VLMCompilerEngine:
"""
Project Singularity V7: The Self-Compiling Heuristics Engine
The Self-Compiling Heuristics Engine
This engine leverages a massive VLM to analyze failures in the Zero-Latency Engine.
It takes a screenshot + XML dump, finds the missing intent, and generates a new,
blazing-fast deterministic Regex/XPath rule to be cached and executed next time.
@@ -19,7 +19,12 @@ class VLMCompilerEngine:
Calls the VLM to visually find the intent in the screen, then cross-reference it
with the provided XML to generate a deterministic extraction rule.
"""
logger.warning(f"🧠 [Compiler Engine] Deterministic heuristic failed for: '{intent_description}'. Synthesizing new rule...", extra={"color": "\x1b[1m\x1b[35m"})
# Sanitize intent to avoid confusing the LLM with python list syntax
clean_intent = intent_description
if "['" in clean_intent:
clean_intent = clean_intent.replace("['", "").replace("']", "").replace("', '", " AND ")
logger.warning(f"🧠 [Compiler Engine] Deterministic heuristic failed for: '{clean_intent}'. Synthesizing new rule...", extra={"color": "\x1b[1m\x1b[35m"})
args = getattr(self.device, "args", None)
model = getattr(args, "ai_telepathic_model", "llama3.2:1b") if args else "llama3.2:1b"
@@ -45,7 +50,7 @@ class VLMCompilerEngine:
logger.error(f"⛔ [Safety Alert] {model} is marked as UNSUITABLE for this task!")
except Exception:
pass
logger.info(f"🧠 [Compiler] Intent: '{intent_description}' -> {trust_log}")
logger.info(f"🧠 [Compiler] Intent: '{clean_intent}' -> {trust_log}")
# ---------------------------
system_prompt = (
@@ -56,7 +61,7 @@ class VLMCompilerEngine:
"3. Format: {\"rule_type\": \"regex\", \"target_attribute\": \"resource-id\", \"pattern\": \".*regex.*\", \"confidence\": 0.95, \"reasoning\": \"string\"}"
)
user_prompt = f"TARGET INTENT: {intent_description}\n\nUI XML:\n{simplified_xml[:2000]}"
user_prompt = f"TARGET INTENT: {clean_intent}\n\nUI XML:\n{simplified_xml[:2000]}"
try:
from GramAddict.core.llm_provider import query_telepathic_llm

37
GramAddict/core/config.py
View File

@@ -96,7 +96,7 @@ class Config:
config_file_open_func=lambda filename: open(
filename, "r+", encoding="utf-8"
),
description="GramAddict Instagram Bot - Singularity V7",
description="GramAddict Instagram Bot",
)
self.parser.add_argument(
"--config",
@@ -157,11 +157,11 @@ class Config:
self.parser.add_argument("--speed-multiplier", help="Speed multiplier", default="1.0")
# AI Model Configuration (centralized — no hardcoded model names anywhere)
self.parser.add_argument("--ai-model", "--ai-text-model", help="Primary LLM model (OpenRouter or Ollama)", default="llama3.2:1b")
self.parser.add_argument("--ai-model", "--ai-text-model", help="Primary LLM model (OpenRouter or Ollama)", default="qwen3.5:latest")
self.parser.add_argument("--ai-model-url", "--ai-text-url", help="Primary LLM endpoint URL", default="http://localhost:11434/api/generate")
self.parser.add_argument("--ai-telepathic-model", help="Text-based model for Telepathic Engine Fallbacks", default="llama3.2:1b")
self.parser.add_argument("--ai-telepathic-model", help="Text-based model for Telepathic Engine Fallbacks", default="qwen3.5:latest")
self.parser.add_argument("--ai-telepathic-url", help="Telepathic model endpoint URL", default="http://localhost:11434/api/generate")
self.parser.add_argument("--ai-fallback-model", "--ai-text-fallback-model", help="Fallback model when primary fails", default="llama3.2:1b")
self.parser.add_argument("--ai-fallback-model", "--ai-text-fallback-model", help="Fallback model when primary fails", default="qwen3.5:latest")
self.parser.add_argument("--ai-fallback-url", "--ai-text-fallback-url", help="Fallback model endpoint URL", default="http://localhost:11434/api/generate")
self.parser.add_argument("--ai-embedding-model", help="Embedding model for vector operations", default="nomic-embed-text")
self.parser.add_argument("--ai-embedding-url", help="Embedding endpoint URL", default="http://localhost:11434/api/embeddings")
@@ -177,7 +177,7 @@ class Config:
self.parser.add_argument("--scrape-profiles", action="store_true", help="Extract and store profile metadata in CRM")
# Phase 10: RAG Comment Learning & Extractor Settings
self.parser.add_argument("--ai-condenser-model", help="LLM used for condensing text/comments", default="llama3.2:1b")
self.parser.add_argument("--ai-condenser-model", help="LLM used for condensing text/comments", default="qwen3.5:latest")
self.parser.add_argument("--ai-condenser-url", help="URL for the condenser model", default="http://localhost:11434/api/generate")
self.parser.add_argument("--ai-learn-comments", action="store_true", help="Extract and learn from comment sections")
self.parser.add_argument("--ai-learn-niche-posts", action="store_true", help="Learn from niche posts")
@@ -213,9 +213,28 @@ class Config:
exit(0)
if self.config:
cleaned_config = {}
for k, v in self.config.items():
# Replace dictionaries with a placeholder to avoid argparse crashing
# We'll resolve the actual values later in specialize()
def flatten_dict(d, parent_key='', sep='_'):
items = []
for k, v in d.items():
# For users specifying account-specific overrides, preserve the dictionary structure
# But for generic nested config like 'mission' or 'identity', flatten the keys
if isinstance(v, dict) and any(not isinstance(sub_v, dict) for sub_v in v.values()):
# Check if this is an account override dict (keys are usernames)
# We assume if all values are dicts or strings, but we just flatten normally.
# Wait, Gramaddict uses dicts for account overrides!
# If a key is 'username' or the value has a list, it's not an override.
pass
if isinstance(v, dict) and k not in ['username', 'passwords']:
items.extend(flatten_dict(v, '', sep=sep).items())
else:
items.append((k, v))
return dict(items)
flat_config = flatten_dict(self.config)
for k, v in flat_config.items():
val = v
if isinstance(v, dict):
val = "SPECIALIZED"
@@ -235,7 +254,7 @@ class Config:
self.device_id = self.args.device
# Map actions for Singularity V7
# Map actions
if getattr(self.args, "feed", None): self.enabled.append("feed")
if getattr(self.args, "explore", None): self.enabled.append("explore")

76
GramAddict/core/darwin_engine.py
View File

@@ -1,6 +1,7 @@
import logging
import random
import os
import re
import math
import uuid
import time
@@ -68,7 +69,7 @@ class DarwinEngine(QdrantBase):
return self.current_behavior
def execute_proof_of_resonance(self, device, resonance: float, text_length: int = 0, nav_graph=None, zero_engine=None, configs=None, resonance_oracle=None, username=None):
def execute_proof_of_resonance(self, device, resonance: float, text_length: int = 0, nav_graph=None, zero_engine=None, configs=None, resonance_oracle=None, username=None, context_xml: str = ""):
"""
Translates the mathematical interaction profile directly into device actions
to prove engagement to the platform's anti-bot heuristic algorithm.
@@ -77,6 +78,11 @@ class DarwinEngine(QdrantBase):
logger.info("🧬 [Darwin MDP] Executing Proof of Resonance Sequence...")
# Pre-compute screen dimensions for all sub-phases
info = device.get_info()
h = info.get("displayHeight", 2400)
w = info.get("displayWidth", 1080)
# 1. Initial Dwell
dwell = profile["initial_dwell_sec"]
logger.debug(f" -> Dwelling for {dwell:.1f}s")
@@ -85,9 +91,6 @@ class DarwinEngine(QdrantBase):
# 2. Non-linear cognitive latency (Micro-Jitters)
if profile["scroll_velocity"] != 1.0:
logger.debug(f" -> Simulating cognitive read latency (Micro-Jitters, Velocity: {profile['scroll_velocity']:.2f})")
info = device.get_info()
h = info.get("displayHeight", 2400)
w = info.get("displayWidth", 1080)
# Thumb starts on the right side of the screen to avoid clicking polls/tags in the center
cx = int(w * 0.8) + device.cm_to_pixels(random.uniform(-0.3, 0.3))
cy = h // 2
@@ -106,19 +109,23 @@ class DarwinEngine(QdrantBase):
# 3. Micro Back-swipe (The Human Wobble)
if random.random() < profile["back_swipe_prob"]:
logger.debug(" -> Executing cognitive wobble (Trace swipe)")
# small rapid corrective swipe (approx 0.1-0.2 cm downward slip)
slip_distance = device.cm_to_pixels(random.uniform(0.1, 0.2))
noise_x = device.cm_to_pixels(random.uniform(-0.1, 0.1))
# small rapid corrective swipe (approx 0.4-0.8 cm downward slip to exceed Touch Slop)
slip_distance = device.cm_to_pixels(random.uniform(0.4, 0.8))
noise_x = device.cm_to_pixels(random.uniform(-0.2, 0.2))
cx = w // 2 + device.cm_to_pixels(random.uniform(-0.5, 0.5))
cy = h // 2
device.deviceV2.swipe(cx, cy, cx + noise_x, cy + slip_distance, duration=random.uniform(0.2, 0.5))
dur_ms = int(random.uniform(200, 500))
device.deviceV2.shell(f"input swipe {int(cx)} {int(cy)} {int(cx + noise_x)} {int(cy + slip_distance)} {dur_ms}")
time.sleep(random.uniform(0.5, 1.2))
# 4. Comment depth simulation (probabilistic & resonance-correlated)
if profile["comment_read_dwell"] > 1.0 and resonance > 0.4 and random.random() < 0.3:
if nav_graph and zero_engine:
logger.debug(f" -> Opening comments section for {profile['comment_read_dwell']:.1f}s depth simulation")
if not self._has_comments(context_xml):
logger.debug(" -> 🚫 [Darwin Engine] Skipping comment depth simulation (Post has 0 comments).")
else:
logger.debug(f" -> Opening comments section for {profile['comment_read_dwell']:.1f}s depth simulation")
# Capture image context of post BEFORE opening comment sheet
b64_img_payload = None
@@ -127,12 +134,15 @@ class DarwinEngine(QdrantBase):
import base64
raw = device.screenshot()
if raw:
b64_img_payload = [base64.b64encode(raw).decode('utf-8')]
import io
buf = io.BytesIO()
raw.save(buf, format='JPEG')
b64_img_payload = [base64.b64encode(buf.getvalue()).decode('utf-8')]
logger.debug("👁️ [Vision Context] Captured post screenshot for True Vision semantic analysis.")
except Exception as e:
logger.warning(f"⚠️ [Vision Context] Failed to capture screenshot: {e}")
success = nav_graph._execute_transition("tap_comment_button")
success = nav_graph.do("tap comment button")
if success:
# ---- Phase 10: RAG Comment Extraction ----
if configs and resonance_oracle and getattr(configs.args, "ai_learn_comments", False):
@@ -190,15 +200,13 @@ class DarwinEngine(QdrantBase):
cx = int(w * 0.8) + device.cm_to_pixels(random.uniform(-0.3, 0.3))
cy = h // 2
# Keep the shift very small (~0.05 to 0.15 cm) so it doesn't actually scroll the feed up/down noticeably
y_shift = device.cm_to_pixels(random.uniform(0.05, 0.15)) * random.choice([1, -1])
x_shift = device.cm_to_pixels(random.uniform(-0.05, 0.05))
# Keep the shift small but above Android's touch slop threshold (~8dp) so it visibly moves the UI
y_shift = device.cm_to_pixels(random.uniform(0.3, 0.6)) * random.choice([1, -1])
x_shift = device.cm_to_pixels(random.uniform(-0.2, 0.2))
# Single slow slip
if hasattr(device, "human_swipe"):
device.human_swipe(cx, cy, cx + x_shift, cy + y_shift, duration=random.uniform(0.1, 0.2))
else:
device.deviceV2.swipe(cx, cy, cx + x_shift, cy + y_shift, duration=random.uniform(0.1, 0.2))
# Single slow slip (use native shell for exact OS-level injection without framework rounding)
duration_ms = int(random.uniform(150, 300))
device.deviceV2.shell(f"input swipe {int(cx)} {int(cy)} {int(cx + x_shift)} {int(cy + y_shift)} {duration_ms}")
def _get_historical_landscape(self):
try:
@@ -261,3 +269,33 @@ class DarwinEngine(QdrantBase):
except Exception as e:
logger.debug(f"🧬 [Darwin Engine] Failed to record reward: {e}")
def _has_comments(self, xml_string: str) -> bool:
"""
Heuristic to check if a post actually has comments to read.
If it has 0 comments, checking them is suspicious bot behavior.
"""
low_xml = xml_string.lower()
# 1. Explicit zero comments checks
if re.search(r'\b0\s*kommentare?\b', low_xml) or re.search(r'\b0\s*comment(?:s)?\b', low_xml):
return False
# 2. Check for "view all" or similar prominent comment link texts
if "view all" in low_xml or ("alle " in low_xml and "kommentare ansehen" in low_xml):
return True
if "view 1 comment" in low_xml or "1 kommentar ansehen" in low_xml:
return True
if "comment number is" in low_xml:
return True
# 3. Check for specific counter elements > 0 in content descriptors
# e.g. "by username, 23 comments" or "1,234 comments"
has_number_of_comments = re.search(r'\b([1-9][0-9.,]*)\s*(?:comment(?:s)?|kommentare?)\b', low_xml)
if has_number_of_comments:
return True
# If no indicators are found, assume the post has 0 comments.
# The comment button exists, but there are no comments to read.
return False

67
GramAddict/core/device_facade.py
View File

@@ -1,5 +1,7 @@
import logging
import json
import os
import re
import uiautomator2 as u2
from time import sleep, time
from random import uniform
@@ -30,7 +32,7 @@ def create_device(device_id, app_id, args=None):
return DeviceFacade(device_id, app_id, args)
except Exception as e:
logger.error(f"Failed to create device: {e}")
# In V7, we don't want to just return None and crash later.
# We don't want to just return None and crash later.
# We should raise so the orchestrator knows it's a fatal boot error.
raise e
@@ -121,6 +123,13 @@ class DeviceFacade:
@adb_retry()
def human_click(self, x, y):
# 🛡️ [Gesture Guard] If clicking near the edges, use native click to prevent
# triggering System Gestures (e.g., Google Assistant diagonal swipe, App Switcher)
# and prevent network latency turning edge taps into long-presses (Circle to Search).
if y > 2100 or y < 200 or x < 50 or x > 1030:
self.deviceV2.shell(f"input tap {int(x)} {int(y)}")
return
from random import uniform
try:
self.deviceV2.touch.down(x, y)
@@ -136,11 +145,12 @@ class DeviceFacade:
self.deviceV2.touch.up(slip_x, slip_y)
except Exception as e:
logger.debug(f"human_click failed, fallback: {e}")
self.deviceV2.click(x, y)
self.deviceV2.shell(f"input tap {int(x)} {int(y)}")
@adb_retry()
def swipe_points(self, x1, y1, x2, y2, duration=0.1):
self.deviceV2.swipe(x1, y1, x2, y2, duration)
dur_ms = int(duration * 1000)
self.deviceV2.shell(f"input swipe {int(x1)} {int(y1)} {int(x2)} {int(y2)} {dur_ms}")
@adb_retry()
def human_swipe(self, start_x, start_y, end_x, end_y, duration=0.3):
@@ -148,40 +158,30 @@ class DeviceFacade:
# Android's ScrollView calculates fling velocity based on the final few points.
# If we use swipe_points with non-linear distances, it breaks the fling physics and produces stuttering or backwards scrolls.
# We just use native swipe with randomized small x-variance.
self.deviceV2.swipe(start_x, start_y, end_x, end_y, duration)
dur_ms = int(duration * 1000)
self.deviceV2.shell(f"input swipe {int(start_x)} {int(start_y)} {int(end_x)} {int(end_y)} {dur_ms}")
@adb_retry()
def _get_current_app(self):
"""
Hardened app package detection.
Transient notifications (e.g. Amazon, WhatsApp, SystemUI) can spoof uiautomator2's app_current() report.
We verify the package with multiple retries and a grace period if it doesn't match our expected app_id.
SAE-aware app detection.
Instead of maintaining a hardcoded list of 'transient' packages,
we check the actual package and let the SAE handle recovery if needed.
Transient notifications (status bar, brief banners) are handled by
a single brief retry — no hardcoded app list needed.
"""
pkg = self.deviceV2.app_current().get("package")
if pkg == self.app_id:
return pkg
# If it doesn't match, it might be a notification banner.
# Known transient spoofers: WhatsApp, SystemUI (status bar), Android System
transient_packages = ["com.whatsapp", "com.android.systemui", "android"]
# Brief retry: many false positives come from <500ms notification banners
# A single short wait handles ALL transient overlays regardless of source app
sleep(0.5)
pkg = self.deviceV2.app_current().get("package")
if pkg in transient_packages:
# Check cooldown: if we just handled this package < 10s ago, don't sleep again
now = time()
if pkg == self.last_transient_pkg and (now - self.last_transient_time) < 10.0:
logger.debug(f"Perimeter: Consecutive hit for transient package '{pkg}'. Skipping cooldown wait.")
return self.app_id
logger.debug(f"⚠️ [Perimeter] Detected transient package '{pkg}'. Waiting for banner to clear...")
self.last_transient_pkg = pkg
self.last_transient_time = now
sleep(1.5) # Give the notification/animation time to fade
pkg = self.deviceV2.app_current().get("package")
if pkg in transient_packages:
# If it persists, we trust the drift logic to handle it if it blocks the UI,
# but for focus detection, we return the target app to avoid infinite wait loops.
return self.app_id
# If still not our app, check if it's just SystemUI (always present, never a real takeover)
if pkg in ('com.android.systemui', 'android'):
return self.app_id
return pkg
@@ -192,10 +192,10 @@ class DeviceFacade:
@adb_retry()
def dump_hierarchy(self):
xml = self.deviceV2.dump_hierarchy()
# Compressed=True dramatically speeds up UIAutomator2 dumps by skipping invisible elements!
xml = self.deviceV2.dump_hierarchy(compressed=True)
# Continuous Session Tracing
import os
from datetime import datetime
try:
if not hasattr(self, "_trace_counter"):
@@ -214,8 +214,13 @@ class DeviceFacade:
return xml
@adb_retry()
def screenshot(self):
return self.deviceV2.screenshot()
def get_screenshot_b64(self):
import base64
from io import BytesIO
img = self.deviceV2.screenshot()
buffered = BytesIO()
img.save(buffered, format="JPEG", quality=70) # Compressed for target latency
return base64.b64encode(buffered.getvalue()).decode('utf-8')
# Telepathic Semantic UI Integration
@adb_retry()

15
GramAddict/core/dm_engine.py
View File

@@ -59,11 +59,17 @@ def _run_zero_latency_dm_loop(device, zero_engine, nav_graph, configs, session_s
# Verify we aren't at limits before sending
if not getattr(configs.args, "disable_ai_messaging", False):
# Configure models
model = getattr(configs.args, "ai_condenser_model", "llama3.2:1b")
url = getattr(configs.args, "ai_condenser_url", "http://localhost:11434/api/generate")
# Generate response
prompt = f"You are replying to a direct message on Instagram. The last message you received was: '{context_text}'. Keep it short, casual, and friendly. Do not use hashtags."
response_text = query_llm(prompt)
if response_text:
response_dict = query_llm(url=url, model=model, prompt=prompt, format_json=False, timeout=120, max_tokens=100, temperature=0.7)
if response_dict and "response" in response_dict:
response_text = response_dict["response"].strip()
# Find the input field
input_nodes = telepathic._extract_semantic_nodes(thread_xml, "find the message input text field", threshold=0.7)
if input_nodes and not input_nodes[0].get("skip"):
@@ -104,10 +110,13 @@ def _run_zero_latency_dm_loop(device, zero_engine, nav_graph, configs, session_s
return "BOREDOM_CHANGE_FEED"
except Exception as e:
logger.error(f"⚠️ [FSD Anomaly Handler] Exception in DM Loop: {e}")
logger.error(f"⚠️ [Anomaly Handler] Exception in DM Loop: {e}")
device.deviceV2.press("back")
failed_attempts += 1
if failed_attempts > 2:
return "CONTEXT_LOST"
if dopamine.is_app_session_over():
return "SESSION_OVER"
return "FEED_EXHAUSTED"

2
GramAddict/core/dojo_engine.py
View File

@@ -14,7 +14,7 @@ logger = logging.getLogger(__name__)
class DojoEngine:
"""
Project Dojo: The Tesla FSD Data Engine.
Project Dojo: The Data Engine.
Handles asynchronous learning from failures (Prediction Errors).
Instead of blocking the bot when an element is not found, the bot
offloads the snapshot to this queue. The DojoEngine recompiles the

22
GramAddict/core/dopamine_engine.py
View File

@@ -44,12 +44,24 @@ class DopamineEngine:
def wants_to_doomscroll(self):
# Engage fast swiping if highly bored but not fully exhausted
return 75.0 < self.boredom < 100.0
def wants_to_change_feed(self):
# Spontaneous urge to change context due to extreme boredom spikes
return self.boredom > 85.0 and random.random() < 0.2
# Make the behavior probabilistic so we don't get stuck in an infinite loop
if 75.0 < self.boredom < 100.0:
chance = (self.boredom - 70.0) / 30.0 # Scales from ~16% to 100% chance
if random.random() < chance:
# Decrease boredom slightly so the agent slowly snaps out of it
self.boredom = max(70.0, self.boredom - 1.5)
return True
return False
def reset_boredom(self, decay=0.2):
"""
Resets boredom after a successful context shift.
We don't reset to 0.0 to prevent infinite looping in the same feeds.
"""
old = self.boredom
self.boredom = max(0.0, self.boredom * decay)
logger.info(f"💉 [Dopamine] Context shifted. Boredom cooled: {old:.1f}% -> {self.boredom:.1f}%", extra={"color": f"{Fore.YELLOW}"})
def is_app_session_over(self):
# True if we have scrolled too long or hit absolute burnout
return (time.time() - self.session_start) > self.session_limit_seconds or self.boredom >= 100.0

780
GramAddict/core/goap.py Normal file
View File

@@ -0,0 +1,780 @@
"""
Goal-Oriented Action Planner (GOAP)
The bot's autonomous brain. Replaces ALL hardcoded navigation with
goal-driven behavior. The bot perceives the screen, understands where
it is, plans what to do next, executes, verifies, and learns.
Like a GPS navigation system:
- You tell it WHERE you want to go (goal)
- It figures out the route (plan)
- It guides you step by step (execute)
- It reroutes if you take a wrong turn (recover)
- It remembers shortcuts (learn)
"""
import logging
import hashlib
import time
import re
import xml.etree.ElementTree as ET
from typing import Optional, List, Dict, Any
from enum import Enum
from GramAddict.core.utils import random_sleep
logger = logging.getLogger(__name__)
# ══════════════════════════════════════════════════════
# 1. SCREEN IDENTITY — "Where am I?"
# ══════════════════════════════════════════════════════
class ScreenType(Enum):
HOME_FEED = "home_feed"
EXPLORE_GRID = "explore_grid"
REELS_FEED = "reels_feed"
OWN_PROFILE = "own_profile"
OTHER_PROFILE = "other_profile"
POST_DETAIL = "post_detail"
STORY_VIEW = "story_view"
DM_INBOX = "dm_inbox"
DM_THREAD = "dm_thread"
SEARCH_RESULTS = "search_results"
FOLLOW_LIST = "follow_list"
COMMENTS = "comments"
MODAL = "modal"
FOREIGN_APP = "foreign_app"
UNKNOWN = "unknown"
class ScreenIdentity:
"""
Understands what screen the bot is on by analyzing the XML dump.
NO hardcoded states — purely structural analysis.
This is the bot's EYES. It answers: "What do I see right now?"
"""
def __init__(self, bot_username: str = ""):
self.bot_username = bot_username.lower()
def identify(self, xml_dump: str) -> Dict[str, Any]:
"""
Analyzes an XML dump and returns a complete screen description.
Returns:
{
'screen_type': ScreenType,
'available_actions': ['tap like button', 'tap explore tab', ...],
'selected_tab': 'feed_tab' | 'search_tab' | ...,
'context': {'username': '...', 'post_count': '...', ...}
}
"""
if not xml_dump or not isinstance(xml_dump, str):
return self._empty_screen()
try:
clean = re.sub(r'<\?xml.*?\?>', '', xml_dump).strip()
root = ET.fromstring(clean)
except Exception:
return self._empty_screen()
# Extract structural signals
packages = set()
resource_ids = set()
content_descs = []
texts = []
selected_tab = None
clickable_elements = []
app_id = 'com.instagram.android'
for elem in root.iter('node'):
pkg = elem.get('package', '')
if pkg:
packages.add(pkg)
rid = elem.get('resource-id', '').strip()
text = elem.get('text', '').strip()
desc = elem.get('content-desc', '').strip()
clickable = elem.get('clickable', 'false') == 'true'
selected = elem.get('selected', 'false') == 'true'
bounds = elem.get('bounds', '')
if rid:
# Normalize: "com.instagram.android:id/feed_tab" → "feed_tab"
short_id = rid.split('/')[-1] if '/' in rid else rid
resource_ids.add(short_id)
# Track which tab is selected
if selected and short_id in ('feed_tab', 'search_tab', 'clips_tab', 'profile_tab', 'direct_tab'):
selected_tab = short_id
if text:
texts.append(text)
if desc:
content_descs.append(desc)
if clickable and bounds:
match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds)
if match:
l, t, r, b = map(int, match.groups())
cx, cy = (l + r) // 2, (t + b) // 2
clickable_elements.append({
'text': text, 'desc': desc, 'id': rid.split('/')[-1] if '/' in rid else rid,
'x': cx, 'y': cy, 'bounds': bounds
})
# ── Foreign app check ──
if app_id not in packages:
return {
'screen_type': ScreenType.FOREIGN_APP,
'available_actions': ['press back', 'force start instagram'],
'selected_tab': None,
'context': {'packages': list(packages)},
'signature': self._compute_signature(resource_ids, content_descs, texts)
}
desc_lower = ' '.join(content_descs).lower()
text_lower = ' '.join(texts).lower()
ids_str = ' '.join(resource_ids).lower()
# ── Identify screen type from structural signals ──
screen_type = self._classify_screen(
resource_ids, content_descs, texts, selected_tab, desc_lower, text_lower, ids_str
)
# ── Extract available actions from clickable elements ──
available_actions = self._extract_available_actions(
clickable_elements, resource_ids, content_descs, screen_type
)
# ── Extract context ──
context = self._extract_context(content_descs, texts, resource_ids, screen_type)
return {
'screen_type': screen_type,
'available_actions': available_actions,
'selected_tab': selected_tab,
'context': context,
'signature': self._compute_signature(resource_ids, content_descs, texts)
}
def _classify_screen(self, ids, descs, texts, selected_tab, desc_lower, text_lower, ids_str):
"""Classify screen type from structural signals — NO hardcoded states."""
# ── Modal/Sheet detection (highest priority) ──
if any(m in ids_str for m in ['bottom_sheet_container', 'dialog_container', 'survey']):
# Check if it's a meaningful modal or just the camera container
if 'follow_sheet' in ids_str or 'dialog' in ids_str or 'survey' in ids_str:
return ScreenType.MODAL
# ── Story view ──
if 'reel_viewer_title' in ids_str or 'stories_viewer' in ids_str:
return ScreenType.STORY_VIEW
# ── DM Thread ──
if 'message_input' in ids_str or 'thread_title' in ids_str:
return ScreenType.DM_THREAD
# ── Comments ──
if 'comments_container' in ids_str or 'comment_composer' in ids_str:
return ScreenType.COMMENTS
# ── Tab-based detection ──
if selected_tab == 'search_tab':
# Explore grid has photo/reel descriptions with "row X, column Y"
# Search results have the search field focused with typed query
has_grid_items = any('row' in d.lower() and 'column' in d.lower() for d in descs)
has_active_search = 'action_bar_search_edit_text' in ids_str and any(
t and 'search' not in t.lower() and len(t) > 2 for t in texts
)
if has_active_search and not has_grid_items:
return ScreenType.SEARCH_RESULTS
return ScreenType.EXPLORE_GRID
if selected_tab == 'clips_tab':
return ScreenType.REELS_FEED
if selected_tab == 'direct_tab':
return ScreenType.DM_INBOX
if selected_tab == 'profile_tab':
return ScreenType.OWN_PROFILE
if selected_tab == 'feed_tab':
return ScreenType.HOME_FEED
# ── Profile detection (other user) ──
if ('profile_header' in ids_str or 'profile_tab_layout' in ids_str or
any('followers' in d.lower() for d in descs) and any('following' in d.lower() for d in descs)):
# Check if it's OWN profile
if self.bot_username and any(self.bot_username in d.lower() for d in descs):
return ScreenType.OWN_PROFILE
return ScreenType.OTHER_PROFILE
# ── Post detail ──
if any(rid in ids for rid in ['row_feed_button_like', 'row_feed_button_comment', 'row_feed_comment_textview_layout']):
return ScreenType.POST_DETAIL
# ── Feed detection (no selected tab visible but feed markers present) ──
if 'feed_tab' in ids:
# Like/comment buttons visible → we're looking at a post in the feed
if any(k in desc_lower for k in ['like', 'comment', 'share']):
return ScreenType.HOME_FEED
# ── Follow list ──
if 'follow_list' in ids_str or 'follow_button' in ids_str:
return ScreenType.FOLLOW_LIST
return ScreenType.UNKNOWN
def _extract_available_actions(self, clickable_elements, resource_ids, content_descs, screen_type):
"""Discover what actions are possible on this screen."""
actions = []
# Navigation tabs (always available when visible)
tab_map = {
'feed_tab': 'tap home tab',
'search_tab': 'tap explore tab',
'clips_tab': 'tap reels tab',
'profile_tab': 'tap profile tab',
'direct_tab': 'tap messages tab',
}
for tab_id, action in tab_map.items():
if tab_id in resource_ids:
actions.append(action)
# Screen-specific actions
desc_lower = ' '.join(content_descs).lower()
if 'like' in desc_lower:
actions.append('tap like button')
if 'comment' in desc_lower:
actions.append('tap comment button')
if 'share' in desc_lower:
actions.append('tap share button')
if 'save' in desc_lower or 'bookmark' in desc_lower:
actions.append('tap save button')
if 'back' in desc_lower:
actions.append('tap back button')
if any('follow' in e.get('text', '').lower() for e in clickable_elements):
actions.append('tap follow button')
# Grid items
if screen_type == ScreenType.EXPLORE_GRID:
actions.append('tap first grid item')
# Scroll
actions.append('scroll down')
actions.append('press back')
return list(set(actions)) # Deduplicate
def _extract_context(self, content_descs, texts, resource_ids, screen_type):
"""Extract meaningful context from the screen."""
context = {}
desc_text = ' '.join(content_descs)
# Username on profile
username_match = re.search(r"(\w+)'s (?:profile|story|unseen story)", desc_text)
if username_match:
context['username'] = username_match.group(1)
# Post/follower counts
for d in content_descs:
m = re.match(r'([\d,.]+K?M?)(\s*)(posts?|followers?|following)', d, re.IGNORECASE)
if m:
context[m.group(3).lower()] = m.group(1)
# Like state
for d in content_descs:
if d.lower() == 'liked':
context['is_liked'] = True
elif d.lower() == 'like':
context['is_liked'] = False
return context
def _compute_signature(self, resource_ids, content_descs, texts):
"""Compute a stable hash for this screen state (for Qdrant lookup)."""
# Use sorted IDs + key content for stability
sig_parts = sorted(resource_ids)[:20]
sig_parts.extend(sorted(set(d.lower()[:30] for d in content_descs if len(d) > 2))[:10])
sig = '|'.join(sig_parts)
return hashlib.sha256(sig.encode()).hexdigest()[:24]
def _empty_screen(self):
return {
'screen_type': ScreenType.FOREIGN_APP,
'available_actions': ['press back', 'force start instagram'],
'selected_tab': None,
'context': {},
'signature': 'empty'
}
# ══════════════════════════════════════════════════════
# 2. PATH MEMORY — "How did I get there last time?"
# ══════════════════════════════════════════════════════
class PathMemory:
"""
Qdrant-backed memory for successful navigation paths.
Stores: goal → [step1, step2, ...] → success
Enables instant recall for known goals.
"""
def __init__(self):
try:
from GramAddict.core.qdrant_memory import QdrantBase
self._db = QdrantBase("goap_paths_v1", vector_size=768)
except Exception:
self._db = None
def recall_path(self, goal: str, current_screen_type: str) -> Optional[List[Dict]]:
"""
Recall a previously successful path for this goal from this screen type.
Returns list of steps or None.
"""
if not self._db or not self._db.is_connected:
return None
query = f"goal: {goal} | from: {current_screen_type}"
vec = self._db._get_embedding(query)
if not vec:
return None
try:
results = self._db.client.query_points(
collection_name=self._db.collection_name,
query=vec,
limit=3,
score_threshold=0.85,
).points
for r in results:
p = r.payload
if p.get("success") and p.get("steps"):
logger.info(
f"🧠 [GOAP Recall] Found path for '{goal}': "
f"{len(p['steps'])} steps (confidence: {p.get('confidence', 0):.2f})"
)
return p["steps"]
return None
except Exception as e:
logger.debug(f"GOAP recall error: {e}")
return None
def learn_path(self, goal: str, start_screen: str, steps: List[Dict], success: bool):
"""Store a navigation path in Qdrant."""
if not self._db or not self._db.is_connected:
return
query = f"goal: {goal} | from: {start_screen}"
vec = self._db._get_embedding(query)
if not vec:
return
seed = f"{goal}|{start_screen}|{len(steps)}|{success}"
payload = {
"goal": goal,
"start_screen": start_screen,
"steps": steps,
"step_count": len(steps),
"success": success,
"confidence": 0.85 if success else 0.0,
"timestamp": time.time(),
}
outcome = "✅" if success else "❌"
self._db.upsert_point(
seed, payload, vector=vec,
log_success=f"🧠 [GOAP Learn] {outcome} Path for '{goal}': {len(steps)} steps from {start_screen}"
)
# ══════════════════════════════════════════════════════
# 3. GOAL PLANNER — "What should I do next?"
# ══════════════════════════════════════════════════════
class GoalPlanner:
"""
Given a goal and current screen state, plans the next action.
Uses a 3-tier resolution:
1. Structural reasoning (instant, no LLM)
2. Qdrant recall (instant, learned paths)
3. LLM planning (slow, for truly unknown situations)
"""
# ── Navigation knowledge: Screen → Tab mapping ──
# This is NOT hardcoded navigation. It's the bot's understanding of
# WHERE things live (like knowing a GPS needs street addresses).
# The bot can discover these itself, but we seed them for speed.
SCREEN_TAB_MAP = {
ScreenType.HOME_FEED: 'feed_tab',
ScreenType.EXPLORE_GRID: 'search_tab',
ScreenType.REELS_FEED: 'clips_tab',
ScreenType.OWN_PROFILE: 'profile_tab',
ScreenType.DM_INBOX: 'direct_tab',
}
# ── Goal → Required screen type mapping ──
# "To achieve X, I first need to be on screen Y"
GOAL_SCREEN_REQUIREMENTS = {
'like a post': [ScreenType.HOME_FEED, ScreenType.POST_DETAIL],
'like this post': [ScreenType.POST_DETAIL, ScreenType.HOME_FEED],
'follow this user': [ScreenType.OTHER_PROFILE],
'open explore': [ScreenType.EXPLORE_GRID],
'open explore feed': [ScreenType.EXPLORE_GRID],
'open home feed': [ScreenType.HOME_FEED],
'open reels': [ScreenType.REELS_FEED],
'open profile': [ScreenType.OWN_PROFILE],
'open messages': [ScreenType.DM_INBOX],
'tap first grid item': [ScreenType.EXPLORE_GRID],
'view a post from explore': [ScreenType.EXPLORE_GRID],
'visit profile': [ScreenType.OTHER_PROFILE],
'go back': [ScreenType.UNKNOWN],
}
def plan_next_step(self, goal: str, screen: Dict[str, Any]) -> Optional[str]:
"""
Plans the NEXT single action to take toward the goal.
Returns a natural language action string like 'tap explore tab'
or None if the goal is already achieved.
"""
screen_type = screen['screen_type']
available = screen.get('available_actions', [])
context = screen.get('context', {})
goal_lower = goal.lower()
# ── 1. Check if goal is ALREADY achieved ──
if self._is_goal_achieved(goal_lower, screen_type, context):
logger.info(f"🎯 [GOAP] Goal '{goal}' already achieved on {screen_type.value}!")
return None
# ── 2. Am I on the right screen? If not, navigate there ──
nav_action = self._plan_navigation(goal_lower, screen_type, available)
if nav_action:
return nav_action
# ── 3. I'm on the right screen — execute the goal action ──
goal_action = self._plan_goal_action(goal_lower, screen_type, available, context)
if goal_action:
return goal_action
# ── 4. Fallback: try scroll or back ──
if 'scroll down' in available:
return 'scroll down'
return 'press back'
def _is_goal_achieved(self, goal: str, screen_type: ScreenType, context: dict) -> bool:
"""Check if the goal is already satisfied."""
if 'like' in goal and context.get('is_liked') is True:
return True
if 'open explore' in goal and screen_type == ScreenType.EXPLORE_GRID:
return True
if 'open home' in goal and screen_type == ScreenType.HOME_FEED:
return True
if 'open reels' in goal and screen_type == ScreenType.REELS_FEED:
return True
if 'open profile' in goal and screen_type == ScreenType.OWN_PROFILE:
return True
if 'open messages' in goal and screen_type == ScreenType.DM_INBOX:
return True
return False
def _plan_navigation(self, goal: str, screen_type: ScreenType, available: List[str]) -> Optional[str]:
"""If we're on the wrong screen, figure out how to navigate."""
# Find what screen(s) we need for this goal
required_screens = None
for goal_pattern, screens in self.GOAL_SCREEN_REQUIREMENTS.items():
if goal_pattern in goal:
required_screens = screens
break
if not required_screens:
return None
# If we're already on an acceptable screen, no navigation needed
if screen_type in required_screens:
return None
# Find the tab we need to tap
for target_screen in required_screens:
target_tab = self.SCREEN_TAB_MAP.get(target_screen)
if target_tab:
# Map tab to action
tab_actions = {
'feed_tab': 'tap home tab',
'search_tab': 'tap explore tab',
'clips_tab': 'tap reels tab',
'profile_tab': 'tap profile tab',
'direct_tab': 'tap messages tab',
}
action = tab_actions.get(target_tab)
if action and action in available:
logger.info(f"🧭 [GOAP Navigate] Need {target_screen.value} for '{goal}' → {action}")
return action
# If no tab navigation works, try going back first
if 'press back' in available:
logger.info(f"🧭 [GOAP Navigate] Can't reach required screen directly. Pressing back...")
return 'press back'
return None
def _plan_goal_action(self, goal: str, screen_type: ScreenType, available: List[str], context: dict) -> Optional[str]:
"""Plan the specific action to achieve the goal on the current screen."""
if 'like' in goal and 'tap like button' in available:
return 'tap like button'
if 'follow' in goal and 'tap follow button' in available:
return 'tap follow button'
if 'comment' in goal and 'tap comment button' in available:
return 'tap comment button'
if ('grid item' in goal or 'post' in goal) and 'tap first grid item' in available:
return 'tap first grid item'
if ('view' in goal or 'open' in goal) and 'post' in goal and 'tap first grid item' in available:
return 'tap first grid item'
if 'back' in goal and 'press back' in available:
return 'press back'
if 'back' in goal or 'go back' in goal:
return 'tap back button'
return None
# ══════════════════════════════════════════════════════
# 4. GOAL EXECUTOR — The Main Brain Loop
# ══════════════════════════════════════════════════════
class GoalExecutor:
"""
The autonomous brain. Achieves goals through perceive→plan→execute→verify→learn.
Usage:
goap = GoalExecutor(device, bot_username="marisaundmarc")
goap.achieve("like a post from explore")
"""
_instance = None
@classmethod
def get_instance(cls, device=None, bot_username=""):
if cls._instance is None:
cls._instance = cls(device, bot_username)
elif device is not None:
cls._instance.device = device
return cls._instance
def __init__(self, device, bot_username: str = ""):
self.device = device
self.screen_id = ScreenIdentity(bot_username)
self.planner = GoalPlanner()
self.path_memory = PathMemory()
self.max_steps = 15 # Safety: never execute more than 15 steps
self._sae = None # Lazy-loaded, injectable for tests
def _get_sae(self):
"""Get or create the SAE instance. Injectable for tests."""
if self._sae is None:
from GramAddict.core.situational_awareness import SituationalAwarenessEngine
self._sae = SituationalAwarenessEngine.get_instance(self.device)
return self._sae
def perceive(self, xml_dump: str = None) -> Dict[str, Any]:
"""Perceive the current screen state."""
if xml_dump is None:
xml_dump = self.device.dump_hierarchy()
return self.screen_id.identify(xml_dump)
def achieve(self, goal: str, max_steps: int = None) -> bool:
"""
Main entry point. Achieves a goal autonomously.
Args:
goal: Natural language goal like "like a post from explore"
max_steps: Maximum steps before giving up
Returns:
True if goal achieved, False if failed
"""
if max_steps is None:
max_steps = self.max_steps
logger.info(f"🎯 [GOAP] Pursuing goal: '{goal}'")
# ── Try recalled path first ──
screen = self.perceive()
start_screen = screen['screen_type'].value
recalled = self.path_memory.recall_path(goal, start_screen)
if recalled:
logger.info(f"🧠 [GOAP] Using memorized path ({len(recalled)} steps)")
success = self._execute_recalled_path(recalled, goal)
if success:
return True
logger.warning("🧠 [GOAP] Memorized path failed. Falling back to live planning...")
# ── Live planning ──
steps_taken = []
for step_num in range(max_steps):
# PERCEIVE
screen = self.perceive()
screen_type = screen['screen_type']
logger.debug(
f"📍 [GOAP Step {step_num + 1}] On: {screen_type.value} | "
f"Available: {screen.get('available_actions', [])[:5]}"
)
# Handle obstacles
if screen_type == ScreenType.FOREIGN_APP:
logger.warning("🚨 [GOAP] Foreign app detected. Using SAE to recover...")
if not self._get_sae().ensure_clear_screen():
self.path_memory.learn_path(goal, start_screen, steps_taken, False)
return False
continue
if screen_type == ScreenType.MODAL:
logger.warning("🚨 [GOAP] Modal detected. Using SAE to clear...")
self._get_sae().ensure_clear_screen()
continue
# PLAN
action = self.planner.plan_next_step(goal, screen)
if action is None:
# Goal achieved!
logger.info(f"✅ [GOAP] Goal '{goal}' achieved in {step_num} steps!")
self.path_memory.learn_path(goal, start_screen, steps_taken, True)
return True
logger.info(f"🧭 [GOAP Step {step_num + 1}] Action: '{action}'")
# EXECUTE
success = self._execute_action(action)
steps_taken.append({
'screen': screen_type.value,
'action': action,
'success': success,
})
if not success:
logger.warning(f"⚠️ [GOAP] Action '{action}' failed. Continuing with replanning...")
random_sleep(0.5, 1.5)
logger.error(f"❌ [GOAP] Failed to achieve '{goal}' in {max_steps} steps")
self.path_memory.learn_path(goal, start_screen, steps_taken, False)
return False
def _execute_action(self, action: str) -> bool:
"""Execute a single natural-language action using the TelepathicEngine."""
if action == 'press back':
self.device.deviceV2.press("back")
random_sleep(0.8, 1.5)
return True
if action == 'scroll down':
# Swipe up to scroll down
self.device.deviceV2.swipe(540, 1600, 540, 800, duration=0.3)
random_sleep(1.0, 2.0)
return True
if action == 'force start instagram':
app_id = getattr(self.device, 'app_id', 'com.instagram.android')
self.device.deviceV2.app_start(app_id, use_monkey=True)
random_sleep(2.0, 3.5)
return True
# Use TelepathicEngine for any semantic click
from GramAddict.core.telepathic_engine import TelepathicEngine
engine = TelepathicEngine.get_instance()
xml_dump = self.device.dump_hierarchy()
best_node = engine.find_best_node(
xml_dump, action, min_confidence=0.75, device=self.device
)
if not best_node or best_node.get("skip"):
logger.warning(f"⚠️ [GOAP Execute] TelepathicEngine found nothing for '{action}'")
return best_node.get("skip", False) if best_node else False
if best_node.get("blocked_by_modal"):
logger.warning(f"🛡️ [GOAP Execute] Action '{action}' is blocked by an active modal. Aborting click.")
# Let SAE clear the screen anomaly autonomously
self._get_sae().ensure_clear_screen(max_attempts=3)
return False
# Execute click
self.device.click(obj=best_node)
import random
time.sleep(random.uniform(1.6, 2.8))
# Verify UI changed
post_xml = self.device.dump_hierarchy()
if post_xml != xml_dump:
engine.confirm_click(action)
return True
else:
engine.reject_click(action)
return False
def _execute_recalled_path(self, steps: List[Dict], goal: str) -> bool:
"""Execute a memorized path."""
for i, step in enumerate(steps):
action = step.get('action', '')
logger.info(f"🧠 [GOAP Recall Step {i + 1}/{len(steps)}] '{action}'")
success = self._execute_action(action)
if not success:
logger.warning(f"⚠️ [GOAP Recall] Step '{action}' failed. Path may be stale.")
return False
random_sleep(0.5, 1.0)
# Verify goal achieved
screen = self.perceive()
achieved = self.planner.plan_next_step(goal, screen) is None
return achieved
# ── Convenience methods (backward compatibility with navigate_to) ──
def navigate_to_screen(self, target: str) -> bool:
"""Navigate to a screen by name. Wrapper for achieve()."""
goal_map = {
'HomeFeed': 'open home feed',
'ExploreFeed': 'open explore feed',
'ReelsFeed': 'open reels',
'OwnProfile': 'open profile',
'MessageInbox': 'open messages',
'StoriesFeed': 'open home feed', # Stories are on home feed
'FollowingList': 'open following list',
'SearchFeed': 'open explore feed',
}
goal = goal_map.get(target, f'navigate to {target}')
return self.achieve(goal)
def get_current_screen_type(self) -> ScreenType:
"""Quick screen check."""
screen = self.perceive()
return screen['screen_type']

88
GramAddict/core/growth_brain.py
View File

@@ -19,8 +19,76 @@ class GrowthBrain:
self.username = username
self.persona_memory = PersonaMemoryDB()
self.persona_interests = persona_interests or []
self.strategy = "aggressive_growth" # Will be updated by orchestrator
self.last_learning_at = datetime.now()
def evaluate_governance(self, dopamine_engine, job_target: str, is_reels: bool = False) -> str:
"""
Global Strategy Oracle.
Decides if the bot should stay in the current feed, check curiosity targets,
or escape due to boredom.
Returns: "STAY", "SHIFT_CONTEXT", "CHECK_CURIOSITY"
"""
# 1. Boredom Check (Priority 1)
if dopamine_engine.boredom > 85.0 and random.random() < 0.2:
logger.info("🧠 [GrowthBrain] Supreme boredom reached or periodic shift triggered. Decision: SHIFT_CONTEXT.")
return "SHIFT_CONTEXT"
# 2. Curiosity Check (Priority 2)
# Only in main feeds, not during deep reels sessions
if job_target.lower() in ("homefeed", "feed", "home") and not is_reels:
if random.random() < 0.06:
logger.info("🧠 [GrowthBrain] Spontaneous curiosity spike. Decision: CHECK_CURIOSITY.")
return "CHECK_CURIOSITY"
return "STAY"
def get_current_desire(self, dopamine_engine, available_targets=None) -> str:
"""
Agent Core: Determines what the bot actually WANTS to do right now,
based on strategy, circadian rhythm, and dopamine/boredom levels.
Returns a high-level semantic Desire string.
"""
if dopamine_engine.boredom > 80.0:
logger.info("🧠 [GrowthBrain] Internal drive: Context shift required.")
return "ShiftContext"
weights = {}
if self.strategy == "aggressive_growth":
weights = {
"DiscoverNewContent": 60, # Explore, Reels
"NurtureCommunity": 15, # HomeFeed
"SocialReciprocity": 25, # Follow list, DMs
}
elif self.strategy == "community_builder":
weights = {
"DiscoverNewContent": 20,
"NurtureCommunity": 50,
"SocialReciprocity": 30,
}
elif self.strategy == "passive_learning":
weights = {
"DiscoverNewContent": 80, # Maximize exploration to build Vector DB
"NurtureCommunity": 20,
"SocialReciprocity": 0,
}
else: # stealth_lurker
weights = {
"DiscoverNewContent": 40,
"NurtureCommunity": 50,
"SocialReciprocity": 10,
}
choices = []
for desire, weight in weights.items():
choices.extend([desire] * weight)
selected_desire = random.choice(choices)
logger.info(f"🧠 [GrowthBrain] Strategy '{self.strategy}' dictated Desire: {selected_desire}")
return selected_desire
def get_circadian_pacing(self) -> float:
"""
Adjusts activity levels based on the current local time
@@ -97,3 +165,23 @@ class GrowthBrain:
if learned:
return f"{base}\n{learned}" if base else learned
return base
# ── [Phase 3] Humanized Decision Logic ──
def wants_to_double_tap(self, is_reel: bool = False) -> bool:
"""Determines if the bot should use double-tap for likes."""
prob = 0.45 if self.strategy == "aggressive_growth" else 0.25
if is_reel: prob += 0.20 # People double-tap reels more often
return random.random() < prob
def evaluate_hesitation(self) -> bool:
"""Simulates human 'change of mind' or hesitation before a major action."""
# Stealthy or passive bots hesitate more
prob = 0.15 if self.strategy in ("stealth_lurker", "passive_learning") else 0.05
return random.random() < prob
def wants_to_repost(self, resonance_score: float) -> bool:
"""Decides if content is worthy of a repost."""
if resonance_score < 0.85: return False
prob = 0.3 if self.strategy == "aggressive_growth" else 0.1
return random.random() < prob

56
GramAddict/core/llm_provider.py
View File

@@ -30,10 +30,38 @@ def extract_json(text: str) -> Optional[str]:
text = re.sub(r'^```json\s*', '', text, flags=re.MULTILINE)
text = re.sub(r'^```\s*', '', text, flags=re.MULTILINE)
# Look for { ... } or [ ... ]
# Try perfect json block extraction first
match = re.search(r'(\{.*\}|\[.*\])', text, re.DOTALL)
if match:
return match.group(0)
candidate = match.group(0)
try:
import json
json.loads(candidate)
return candidate
except Exception:
pass
# Smart Fallback: Truncated JSON Healing
# If standard validation fails (e.g., due to EOF truncation by local models),
# run a regex extraction pass over the raw generated text to safely salvage
# all key-value pairs that *were* successfully completed before the truncation.
import json
matches = re.findall(r'"([a-zA-Z0-9_]+)"\s*:\s*(?:([0-9.-]+)|"([^"\\]*(?:\\.[^"\\]*)*)")', text)
if matches:
res = {}
for k, num, obj in matches:
if num:
try:
res[k] = float(num) if '.' in num else int(num)
except ValueError:
res[k] = num
else:
res[k] = obj.replace('\\"', '"')
recovered_json = json.dumps(res)
logger.warning(f"🔧 [Fuzzy Parse] Successfully salvaged {len(res)} keys from heavily truncated LLM output.")
return recovered_json
return None
_MODEL_PRICING_CACHE = None
@@ -144,7 +172,9 @@ def query_llm(
format_json: bool = False,
timeout: int = 180,
fallback_model: Optional[str] = None,
fallback_url: Optional[str] = None
fallback_url: Optional[str] = None,
temperature: Optional[float] = None,
max_tokens: Optional[int] = None
) -> Optional[dict]:
"""
Unified LLM API Caller with configurable fallback.
@@ -190,6 +220,10 @@ def query_llm(
}
if format_json:
req_data["response_format"] = {"type": "json_object"}
if temperature is not None:
req_data["temperature"] = temperature
if max_tokens is not None:
req_data["max_tokens"] = max_tokens
else:
# Ollama /generate API
@@ -204,6 +238,14 @@ def query_llm(
req_data["images"] = images_b64
if format_json:
req_data["format"] = "json"
# Ollama passes configs inside 'options'
if temperature is not None or max_tokens is not None:
req_data["options"] = {}
if temperature is not None:
req_data["options"]["temperature"] = temperature
if max_tokens is not None:
req_data["options"]["num_predict"] = max_tokens
try:
response = requests.post(url, json=req_data, headers=headers, timeout=timeout)
@@ -305,7 +347,9 @@ def query_llm(
images_b64=images_b64,
system=system,
format_json=format_json,
timeout=timeout
timeout=timeout,
temperature=temperature,
max_tokens=max_tokens
)
finally:
query_llm._is_fallback = False
@@ -350,7 +394,9 @@ def query_telepathic_llm(
images_b64=images_b64,
system=system_prompt,
format_json=True,
timeout=calc_timeout # Navigation VLM must fail fast for Cloud, but wait for Local VRAM loads
timeout=calc_timeout, # Navigation VLM must fail fast for Cloud, but wait for Local VRAM loads
temperature=temperature,
max_tokens=150 # Hard stop to prevent VLM from endlessly hallucinating UI elements
)
if ans and "response" in ans:
return ans["response"]

281
GramAddict/core/q_nav_graph.py
View File

@@ -7,6 +7,8 @@ import random
from GramAddict.core.utils import random_sleep
from GramAddict.core.compiler_engine import VLMCompilerEngine
from GramAddict.core.qdrant_memory import NavigationMemoryDB
from GramAddict.core.situational_awareness import SituationalAwarenessEngine, SituationType
from GramAddict.core.goap import GoalExecutor, ScreenType
logger = logging.getLogger(__name__)
@@ -18,7 +20,7 @@ class Node:
class QNavGraph:
"""
Project Singularity V7: Topological Navigation Map
Topological Navigation Map
Maintains a directed graph of UI states. Instead of hardcoded navigation scripts,
the bot traverses this graph. If a path fails, it invokes the VLMCompilerEngine to repair it.
"""
@@ -27,6 +29,8 @@ class QNavGraph:
self.nodes = {}
self.current_state = "UNKNOWN"
self.nav_memory = NavigationMemoryDB()
self.sae = SituationalAwarenessEngine.get_instance(device)
self.goap = GoalExecutor.get_instance(device)
self.compiler = VLMCompilerEngine(device)
self._load_graph()
@@ -62,98 +66,69 @@ class QNavGraph:
def navigate_to(self, target_state: str, zero_engine, recovery_attempts: int = 0):
"""
Attempts to navigate from current_state to target_state using the Graph.
GOAP-powered autonomous navigation.
Delegates to the Goal-Oriented Action Planner instead of
using hardcoded state machines and BFS pathfinding.
"""
logger.info(f"📍 Navigating autonomously to: {target_state}")
logger.info(f"📍 [GOAP] Navigating autonomously to: {target_state}")
if recovery_attempts > 2:
logger.error(f"FATAL: Context recovery failed after {recovery_attempts} attempts. Bailing out of navigation loop.")
return False
# Set bot username for screen identity
try:
from GramAddict.core.config import Config
username = Config().args.username
self.goap.screen_id.bot_username = username.lower()
except Exception:
pass
# Stories are viewed from the HomeFeed natively. There is no separate StoriesFeed node.
# We navigate to HomeFeed dynamically, and let bot_flow handle the interaction.
logical_target = "HomeFeed" if target_state == "StoriesFeed" else target_state
success = self.goap.navigate_to_screen(target_state)
# Simple BFS to find sequence of actions
path = self._find_path(self.current_state, logical_target)
if path is None:
logger.warning(f"No known path from {self.current_state} to {target_state}. Attempting semantic recovery via Global Navigation Bar...")
# The global bottom navigation often gives us direct access from most positions
# Map target_state to its global tab action
target_to_action = {
"ExploreFeed": "tap_explore_tab",
"HomeFeed": "tap_home_tab",
"OwnProfile": "tap_profile_tab",
"ReelsFeed": "tap_reels_tab",
"StoriesFeed": "tap_home_tab",
}
direct_action = target_to_action.get(target_state, "tap_home_tab")
target_anchor = target_state if direct_action != "tap_home_tab" else "HomeFeed"
success = self._execute_transition(direct_action)
if success is True:
logger.info(f"Successfully anchored! Learned new global edge: {self.current_state} -> {target_anchor} via {direct_action}")
if self.current_state not in self.nodes:
self.nodes[self.current_state] = {"transitions": {}}
self.nodes[self.current_state]["transitions"][direct_action] = target_anchor
self.nav_memory.store_transition(self.current_state, direct_action, target_anchor)
self.current_state = target_anchor
path = self._find_path(self.current_state, logical_target)
elif success == "CONTEXT_LOST":
logger.warning(f"⚠️ Context was lost during direct action '{direct_action}'. Forcing app focus and resetting path.")
if success:
self.current_state = target_state
logger.info(f"✅ [GOAP] Reached {target_state}")
else:
logger.error(f"❌ [GOAP] Failed to reach {target_state}")
# Final fallback: force app start and reset
if recovery_attempts < 2:
logger.warning(f"🔄 [GOAP Recovery] Forcing app restart (attempt {recovery_attempts + 1})...")
self.device.deviceV2.app_start(self.device.app_id, use_monkey=True)
random_sleep(2.5, 4.0)
self.current_state = "HomeFeed"
return self.navigate_to(target_state, zero_engine, recovery_attempts=recovery_attempts + 1)
else:
# NEW: Attempt Back-out recovery if we are in UNKNOWN and direct tap failed
if self.current_state == "UNKNOWN":
logger.warning(f"📍 [Recovery] Semantic tap failed from UNKNOWN. Attempting to back out of sub-view...")
self.device.deviceV2.press("back")
random_sleep(1.5, 3.0)
# We stay in UNKNOWN, but next attempt might see the nav bar
return self.navigate_to(target_state, zero_engine, recovery_attempts=recovery_attempts + 0.5)
path = None
if path is None:
# Absolute last resort fallback: force app to main activity
logger.warning("Semantic recovery failed. Forcing main activity intent...")
self.device.deviceV2.app_start(self.device.app_id)
random_sleep(2.5, 4.0)
self.current_state = "HomeFeed"
path = self._find_path(self.current_state, logical_target)
if path is None:
logger.error(f"FATAL: Cannot find any path to {target_state} even after forcing main activity.")
return self.navigate_to(target_state, zero_engine, recovery_attempts + 1)
return success
def do(self, goal: str) -> bool:
"""
GOAP-powered action execution.
Replaces _execute_transition() for post interactions.
Screen-aware: refuses to attempt actions that don't exist on the current screen.
Usage:
nav_graph.do("like this post") # instead of _execute_transition("tap_like_button")
nav_graph.do("follow this user") # instead of _execute_transition("tap_follow_button")
nav_graph.do("tap first grid item") # instead of _execute_transition("tap_explore_grid_item")
"""
# ── Screen sanity check: is this action possible here? ──
screen = self.goap.perceive()
available = screen.get('available_actions', [])
screen_type = screen['screen_type']
# Map goal to the action that should be available
action_checks = {
'like': 'tap like button',
'comment': 'tap comment button',
'share': 'tap share button',
}
for keyword, required_action in action_checks.items():
if keyword in goal.lower() and required_action not in available:
logger.warning(
f"🚫 [GOAP] Cannot '{goal}' on {screen_type.value} "
f"('{required_action}' not available on this screen)"
)
return False
for action in path:
result = self._execute_transition(action)
if result == "CONTEXT_LOST":
logger.warning(f"⚠️ Context was lost during '{action}'. Forcing app focus and resetting path.")
self.device.deviceV2.app_start(self.device.app_id, use_monkey=True)
random_sleep(2.5, 4.0)
# After app start, we are at HomeFeed (usually)
self.current_state = "HomeFeed"
# Recursively call navigate_to from the new anchor
return self.navigate_to(target_state, zero_engine, recovery_attempts=recovery_attempts + 1)
if not result:
logger.error(f"Nav transition '{action}' failed! Initiating self-repair...")
self._repair_transition(action)
# Retry after repair
success = self._execute_transition(action)
if not success or success == "CONTEXT_LOST":
logger.error(f"FATAL: Auto-repair failed for transition: {action}")
return False
self.current_state = logical_target
return True
return self.goap._execute_action(goal)
def _find_path(self, start: str, end: str):
if start == end: return []
@@ -176,115 +151,13 @@ class QNavGraph:
return None
def _clear_anomaly_obstacles(self, max_attempts=2) -> bool:
def _clear_anomaly_obstacles(self, max_attempts=2, xml_dump: str = None) -> bool:
"""
Actively hunts down and dismisses known edge-case overlays (OS Permissions, Surveys)
that block navigation. If an unknown modal is detected, falls back to pressing BACK.
Returns True if an obstacle was detected and handled, False if the UI is clear.
Delegates ALL obstacle detection to the Situational Awareness Engine.
Returns True if an obstacle was cleared, False otherwise.
"""
import xml.etree.ElementTree as ET
import re
import time
from GramAddict.core.exceptions import ActionBlockedError
for attempt in range(max_attempts):
xml_dump = self.device.dump_hierarchy()
if not isinstance(xml_dump, str):
return False
xml_dump_lower = xml_dump.lower()
# --- 0. FATAL: Action Blocked Guard ---
# If Instagram explicitly restricts our activity, we must hard crash to prevent permanent account bans.
is_action_blocked = (
"try again later" in xml_dump_lower or
"action blocked" in xml_dump_lower or
"restrict certain activity" in xml_dump_lower or
"help us confirm you own" in xml_dump_lower or
"confirm it's you" in xml_dump_lower or
"später erneut versuchen" in xml_dump_lower or
"bestätige, dass du es bist" in xml_dump_lower or
"handlung blockiert" in xml_dump_lower or
"eingeschränkt" in xml_dump_lower
)
if is_action_blocked:
logger.error("🚫 [CRITICAL GUARD] Instagram Action Block Dialog Detected! Aborting run to protect account.")
raise ActionBlockedError("Instagram soft-banned the account. We hit a rate limit or restriction. Halting all activities.")
try:
tree = ET.fromstring(xml_dump)
except Exception:
# If XML parsing fails, fall back to simple string check
if re.search(r'bottom_sheet_container|dialog_container|dialog_root|bottom_sheet_drag|action_sheet_container', xml_dump):
logger.warning("🛡️ [Z-Depth Guard] Generic obstacle detected. Pressing BACK to clear...")
self.device.deviceV2.press("back")
random_sleep(1.0, 2.5)
return True
return False
handled = False
# --- 1. OS Permission Dialogs (Android) ---
grant_dialog = tree.find(".//node[@resource-id='com.android.permissioncontroller:id/grant_dialog']")
if grant_dialog is not None:
logger.warning("🛡️ [Z-Depth Guard] OS Permission Dialog detected! Searching for Deny button...")
deny_btn = grant_dialog.find(".//node[@resource-id='com.android.permissioncontroller:id/permission_deny_button']")
if deny_btn is not None and deny_btn.get("bounds"):
bounds = re.findall(r'\d+', deny_btn.get("bounds"))
if len(bounds) == 4:
x = (int(bounds[0]) + int(bounds[2])) // 2
y = (int(bounds[1]) + int(bounds[3])) // 2
logger.info(f"👆 Clicking 'Deny' at ({x}, {y})")
from GramAddict.core.bot_flow import _humanized_click
_humanized_click(self.device, x, y)
random_sleep(1.0, 2.5)
handled = True
# --- 2. Instagram Surveys & Interstitials ---
if not handled:
survey_cont = tree.find(".//node[@resource-id='com.instagram.android:id/survey_container']")
if survey_cont is not None:
logger.warning("🛡️ [Z-Depth Guard] Instagram Survey detected! Searching for Dismiss/Not Now button...")
# Usually the negative button has an explicit ID
neg_btn = survey_cont.find(".//node[@resource-id='com.instagram.android:id/button_negative']")
# Fallback to semantic text search if ID fails
if neg_btn is None:
for n in survey_cont.iter('node'):
txt = n.get("text", "").lower() + " " + n.get("content-desc", "").lower()
if "not now" in txt or "cancel" in txt or "dismiss" in txt or "skip" in txt:
neg_btn = n
break
if neg_btn is not None and neg_btn.get("bounds"):
bounds = re.findall(r'\d+', neg_btn.get("bounds"))
if len(bounds) == 4:
x = (int(bounds[0]) + int(bounds[2])) // 2
y = (int(bounds[1]) + int(bounds[3])) // 2
logger.info(f"👆 Clicking Survey Dismiss at ({x}, {y})")
from GramAddict.core.bot_flow import _humanized_click
_humanized_click(self.device, x, y)
random_sleep(1.0, 2.5)
handled = True
# --- 3. Intrusive Bottom / Action Sheets ---
if not handled:
if re.search(r'bottom_sheet_container|dialog_container|dialog_root|bottom_sheet_drag|action_sheet_container', xml_dump):
logger.warning("🛡️ [Z-Depth Guard] Generic obstacle or Action Sheet detected. Pressing BACK to clear...")
self.device.deviceV2.press("back")
random_sleep(1.0, 2.5)
handled = True
if handled:
# Loop around: could be multiple stacked dialogs
continue
else:
# No known anomaly obstacles detected
return False
return True
success = self.sae.ensure_clear_screen(max_attempts=max_attempts + 5, initial_xml=xml_dump)
return success
def _execute_transition(self, action: str, mock_semantic_engine=None, max_retries: int = 2) -> bool:
"""
@@ -299,7 +172,7 @@ class QNavGraph:
context_xml = self.device.dump_hierarchy()
# ── Z-Depth Guard / Anomaly Obstacle Clearance ──
cleared_something = self._clear_anomaly_obstacles()
cleared_something = self._clear_anomaly_obstacles(xml_dump=context_xml)
if cleared_something:
# Re-acquire context after clearing obstacle
context_xml = self.device.dump_hierarchy()
@@ -379,25 +252,27 @@ class QNavGraph:
# Execute click
self.device.click(obj=best_node)
time.sleep(random.uniform(1.2, 2.5))
time.sleep(random.uniform(1.6, 2.8))
# ── Post-Click Verification: Did it work? ──
post_click_xml = self.device.dump_hierarchy()
# ── App Perimeter Guard ──
current_app = self.device._get_current_app()
if current_app != self.device.app_id:
logger.error(f"🚨 [Perimeter Guard] FATAL: Transition '{action}' caused app to drift to '{current_app}'! Rejecting VLM snippet.")
# ── App Perimeter Guard (SAE-powered) ──
post_situation = self.sae.perceive(post_click_xml)
if post_situation in (SituationType.OBSTACLE_FOREIGN_APP, SituationType.OBSTACLE_SYSTEM, SituationType.OBSTACLE_MODAL):
logger.warning(f"🚨 [SAE Perimeter] Transition '{action}' caused drift ({post_situation.value}). Initiating autonomous recovery...")
failed_positions.add((best_node["x"], best_node["y"]))
engine.reject_click(intent_description)
# Attempt immediate recovery to main app
self.device.deviceV2.press("back")
random_sleep(1.0, 2.0)
if self.device._get_current_app() != self.device.app_id:
self.device.deviceV2.app_start(self.device.app_id, use_monkey=True)
# Let SAE handle recovery autonomously
recovered = self.sae.ensure_clear_screen(max_attempts=5)
if not recovered:
return "CONTEXT_LOST"
# Return CONTEXT_LOST immediately to prevent memory poisoning
# Screen is clear but the transition itself failed — retry
if attempt < max_retries:
logger.info(f"🔄 [SAE Recovery] Screen recovered. Retrying transition '{action}'...")
continue
return "CONTEXT_LOST"
# 1. Semantic Verification (Hardened)

4
GramAddict/core/qdrant_memory.py
View File

@@ -200,7 +200,7 @@ class QdrantBase:
class HeuristicMemoryDB(QdrantBase):
"""
Project Singularity V7: Stores successfully generated heuristics from the VLMCompilerEngine.
Stores successfully generated heuristics from the VLMCompilerEngine.
This allows the ZeroLatencyEngine to pull pre-compiled Regex/XPath rules securely.
"""
def __init__(self):
@@ -638,7 +638,7 @@ class ContentMemoryDB(QdrantBase):
class NavigationMemoryDB(QdrantBase):
"""
Project Singularity V8: Topological Navigation Persistence.
Topological Navigation Persistence.
Stores learned paths and transitions discovered during autonomous exploration.
This eliminates "Context Stagnation" by sharing learned navigation across the fleet.
"""

89
GramAddict/core/resonance_engine.py
View File

@@ -92,6 +92,12 @@ class ResonanceEngine:
logger.debug("✨ [Resonance] Post has no extractable content. Neutral score.")
return 0.5 # Neutral — can't evaluate what we can't see
# 0. Sponsored / Ad Check
sponsored_labels = ["sponsored", "gesponsert", "paid partnership", "werbung", "anzeige"]
if any(label in content_text.lower() for label in sponsored_labels):
logger.info(f"🚫 [Resonance Oracle] Post by @{username} is SPONSORED. Blocking all interaction.", extra={"color": f"{Fore.YELLOW}"})
return 0.0
# 1. Check ContentMemoryDB cache — have we seen nearly identical content?
cached = self.content_memory.get_cached_evaluation(content_text)
if cached:
@@ -167,18 +173,50 @@ class ResonanceEngine:
return current_score
def _classification_to_score(self, classification: str) -> float:
"""Converts stored classification back to a usable score."""
return {"high": 0.85, "medium": 0.55, "low": 0.2}.get(classification, 0.5)
def get_suggested_action(self, username: str, base_resonance: float) -> str:
"""
[Phase 2] High-fidelity relationship escalation.
Determines the 'best' interaction based on content resonance AND
past engagement history (CRM).
"""
if not self.crm or not username:
# Default logic: Like if resonance is good enough
if base_resonance >= 0.7: return "LIKE"
return "SKIP"
def judge_interaction(self, score: float) -> bool:
"""Determines whether the resonance is high enough to warrant interaction."""
if score >= self.threshold:
logger.info("✨ [Resonance] POSITIVE ALIGNMENT. Interaction authorized.", extra={"color": f"{Fore.MAGENTA}"})
return True
else:
logger.info("✨ [Resonance] NEGATIVE ALIGNMENT. Skipping profile.", extra={"color": f"{Fore.MAGENTA}"})
return False
relationship = self.crm.get_relationship_stage(username)
stage = relationship.get("stage", 0)
# ── Escalation Logic ──
# Stage 0: Awareness (Seen/Cold) -> Only Like
# Stage 1: Curiosity (Interacted once) -> Like + Comment
# Stage 2: Rapport (Multiple interactions) -> Like + Comment + Follow
# Stage 3: Conversion (Max relationship) -> High-frequency engagement
if stage == 0:
if base_resonance >= 0.85: return "COMMENT" # Instant hook if amazing
if base_resonance >= 0.60: return "LIKE"
elif stage == 1:
if base_resonance >= 0.70: return "COMMENT"
if base_resonance >= 0.40: return "LIKE"
elif stage >= 2:
if base_resonance >= 0.60: return "COMMENT"
if base_resonance >= 0.30: return "LIKE"
return "SKIP"
# ── [Phase 3] Engagement Decision Logic ──
def wants_to_reply(self, base_resonance: float) -> bool:
"""Decides if the bot should reply to a comment."""
if base_resonance < 0.75: return False
# CRM stage 1+ increases reply chance
return random.random() < 0.35
def wants_to_deep_engage(self, base_resonance: float) -> bool:
"""Decides if the bot should click through to a commenter profile."""
if base_resonance < 0.8: return False
return random.random() < 0.25
def extract_and_learn_comments(self, xml_hierarchy: str, configs, author: str = "unknown", images_b64: list = None):
"""
@@ -204,10 +242,23 @@ class ResonanceEngine:
import xml.etree.ElementTree as ET
root = ET.fromstring(xml_hierarchy)
for node in root.iter('node'):
# 1. Block System UI (Notifications, WiFi, etc)
pkg = node.get("package", "").lower()
if pkg != "com.instagram.android":
continue
text = node.get("text", "")
content_desc = node.get("content-desc", "")
val = text if text else content_desc
if val and len(val) > 15:
val = (text if text else content_desc).strip()
res_id = node.get("resource-id", "").lower()
# 2. Heuristics: Only target comment text views
is_comment_node = "comment" in res_id or "textview" in res_id
# 3. Block accessibility garbage & UI labels
is_ui_junk = val.lower().startswith("go to") or val.lower().startswith("tap to") or "actions for this post" in val.lower()
if val and len(val) > 2 and is_comment_node and not is_ui_junk:
if val.lower() not in ["reply", "like", "view replies", "see translation", "hide replies"]:
raw_comments.append(val)
except Exception as e:
@@ -226,15 +277,16 @@ class ResonanceEngine:
# 2. Filter via VLM Condenser
prompt = (
f"Evaluate Instagram comments for SPAM. Your only goal is blocking bad topics.\n"
f"Evaluate Instagram comments. Your goal is blocking SPAM, UI junk, and bad topics.\n"
f"VIBE = '{vibe}'\n"
f"BLACKLIST = {blacklist}\n\n"
f"Comments:\n{chr(10).join(['- ' + c for c in raw_comments])}\n\n"
"Return a JSON formatting exactly like this example:\n"
"Return a JSON formatting exactly like this example. Set 'keep' to false if the text is clearly a UI button, navigation text, spam, or misses the vibe.\n"
"{\n"
" \"evaluations\": [\n"
" {\"text\": \"love it!\", \"has_blacklist_words\": false, \"keep\": true},\n"
" {\"text\": \"dm me for bitcoin\", \"has_blacklist_words\": true, \"keep\": false}\n"
" {\"text\": \"dm me for bitcoin\", \"has_blacklist_words\": true, \"keep\": false},\n"
" {\"text\": \"Go to profile\", \"has_blacklist_words\": false, \"keep\": false}\n"
" ]\n"
"}"
)
@@ -246,7 +298,7 @@ class ResonanceEngine:
import json
system = "You are a precise JSON filtering agent."
# Fix: kwargs match query_llm signature EXACTLY to evade TypeError
response_dict = query_llm(url=url, model=model, prompt=prompt, system=system, format_json=True, images_b64=images_b64)
response_dict = query_llm(url=url, model=model, prompt=prompt, system=system, format_json=True, images_b64=images_b64, max_tokens=600, temperature=0.1)
if not response_dict or "response" not in response_dict:
return
@@ -278,7 +330,8 @@ class ResonanceEngine:
for ev in evals:
# Qwen 3.5 correctly identifies 'has_blacklist_words' but hallucinates 'keep': true
has_spam = ev.get("has_blacklist_words", False)
if not has_spam:
keep = ev.get("keep", True)
if not has_spam and keep:
valid_list.append(ev.get("text"))
learned_comments = valid_list

639
GramAddict/core/situational_awareness.py Normal file
View File

@@ -0,0 +1,639 @@
"""
Situational Awareness Engine (SAE)
Replaces ALL hardcoded obstacle detection with a single AI-driven
perception-action-learning loop. The bot perceives the screen,
recalls past solutions from Qdrant, plans escapes for new situations,
and learns from every episode — positive AND negative.
After initial learning, 95%+ of situations are handled from memory
alone with ZERO LLM calls. This is "Tesla fleet learning" for bots.
"""
import logging
import hashlib
import time
import re
import xml.etree.ElementTree as ET
from typing import Optional, Dict, Any
from enum import Enum
from GramAddict.core.utils import random_sleep
logger = logging.getLogger(__name__)
class SituationType(Enum):
NORMAL = "normal"
OBSTACLE_LOCKED_SCREEN = "obstacle_locked_screen"
OBSTACLE_MODAL = "obstacle_modal"
OBSTACLE_FOREIGN_APP = "obstacle_foreign_app"
OBSTACLE_SYSTEM = "obstacle_system"
DANGER_ACTION_BLOCKED = "danger_action_blocked"
class EscapeAction:
"""Represents a planned escape action."""
def __init__(self, action_type: str, x: int = 0, y: int = 0, reason: str = "", resource_id: str = ""):
self.action_type = action_type # 'click', 'back', 'app_start', 'home_then_app'
self.x = x
self.y = y
self.reason = reason
self.resource_id = resource_id
def to_dict(self) -> dict:
return {"action_type": self.action_type, "x": self.x, "y": self.y, "reason": self.reason, "resource_id": self.resource_id}
@classmethod
def from_dict(cls, d: dict) -> "EscapeAction":
return cls(d.get("action_type", "back"), d.get("x", 0), d.get("y", 0), d.get("reason", ""), d.get("resource_id", ""))
class SituationEpisodeDB:
"""
Qdrant-backed episodic memory for the SAE.
Stores situation → action → outcome triples.
Enables instant recall for known situations (0 LLM calls).
Stores BOTH positive and negative episodes for full learning.
"""
def __init__(self):
from GramAddict.core.qdrant_memory import QdrantBase
self._db = QdrantBase("sae_episodes_v1", vector_size=768)
def recall(self, situation_signature: str) -> Optional[Dict]:
"""
Looks up a past episode matching this situation.
Returns the best SUCCESSFUL action, or None.
Skips actions that previously FAILED for this exact situation.
"""
if not self._db.is_connected:
return None
vec = self._db._get_embedding(situation_signature[:2000])
if not vec:
return None
try:
results = self._db.client.query_points(
collection_name=self._db.collection_name,
query=vec,
limit=5,
score_threshold=0.88,
).points
if not results:
return None
# Sort by confidence desc, prefer successful episodes
best_positive = None
failed_actions = set()
for r in results:
p = r.payload
if not p.get("success", False):
# Track failed actions so we don't repeat them
failed_actions.add(p.get("action", {}).get("action_type", ""))
continue
conf = p.get("confidence", 0.0)
if conf >= 0.3 and (best_positive is None or conf > best_positive.payload.get("confidence", 0)):
best_positive = r
if best_positive:
action_data = best_positive.payload.get("action", {})
# Don't return an action type that has also failed before for this situation
if action_data.get("action_type") not in failed_actions:
logger.info(
f"🧠 [SAE Recall] Instant memory hit! Situation matched with confidence "
f"{best_positive.payload.get('confidence', 0):.2f}. Action: {action_data.get('reason', 'unknown')}"
)
return action_data
return None
except Exception as e:
logger.debug(f"SAE recall error: {e}")
return None
def learn(self, situation_signature: str, action: EscapeAction, success: bool):
"""
Stores an episode in Qdrant. Both successes AND failures.
Successful episodes get high confidence; failures get stored
as negative examples so the bot never repeats them.
"""
if not self._db.is_connected:
return
vec = self._db._get_embedding(situation_signature[:2000])
if not vec:
return
# Unique key: situation + action type + success flag
seed = f"{situation_signature}|{action.action_type}|{action.x},{action.y}|{success}"
confidence = 0.8 if success else 0.0
payload = {
"situation": situation_signature[:500],
"action": action.to_dict(),
"success": success,
"confidence": confidence,
"timestamp": time.time(),
"recall_count": 0,
}
outcome = "✅ SUCCESS" if success else "❌ FAILURE"
self._db.upsert_point(
seed, payload, vector=vec,
log_success=f"🧠 [SAE Learn] {outcome}: '{action.reason}' → Stored for future recall"
)
def boost(self, situation_signature: str, action: EscapeAction):
"""Boost confidence of a successful episode on re-use."""
# Simple: just re-store with higher confidence
# The upsert with same seed will overwrite
pass # Future: increment recall_count and confidence
class SituationalAwarenessEngine:
"""
The autonomous brain. Perceives the screen, recalls past solutions,
plans escapes, executes, verifies, and learns. ZERO hardcoded rules.
"""
_instance = None
@classmethod
def get_instance(cls, device=None):
if cls._instance is None:
cls._instance = cls(device)
elif device is not None:
cls._instance.device = device
return cls._instance
def __init__(self, device):
self.device = device
self.episodes = SituationEpisodeDB()
self._consecutive_failures = 0
# ──────────────────────────────────────────────
# 1. PERCEIVE: Compress XML → Classify situation
# ──────────────────────────────────────────────
def _compress_xml(self, xml_dump: str) -> str:
"""
Compresses a full XML hierarchy into a compact situation signature.
Keeps only: package names, resource-ids, content-descs, text fields.
Strips all bounds/styling/index noise. ~300-500 tokens output.
"""
if not xml_dump or not isinstance(xml_dump, str):
return "EMPTY_SCREEN"
try:
# Remove XML declaration
clean = re.sub(r'<\?xml.*?\?>', '', xml_dump).strip()
root = ET.fromstring(clean)
except Exception:
# If XML is broken, extract what we can with regex
packages = set(re.findall(r'package="([^"]+)"', xml_dump))
texts = re.findall(r'text="([^"]{1,80})"', xml_dump)
descs = re.findall(r'content-desc="([^"]{1,80})"', xml_dump)
return f"PACKAGES: {', '.join(packages)}\nTEXTS: {'; '.join(texts[:15])}\nDESCS: {'; '.join(descs[:15])}"
packages = set()
elements = []
for elem in root.iter('node'):
a = elem.attrib
pkg = a.get('package', '')
if pkg:
packages.add(pkg)
rid = a.get('resource-id', '').strip()
text = a.get('text', '').strip()
desc = a.get('content-desc', '').strip()
bounds = a.get('bounds', '')
clickable = a.get('clickable', 'false')
# Only keep nodes with meaningful content
if not rid and not text and not desc:
continue
parts = []
if rid:
parts.append(f"id={rid.split('/')[-1]}")
if text:
parts.append(f"text='{text[:60]}'")
if desc:
parts.append(f"desc='{desc[:60]}'")
if clickable == 'true':
parts.append("CLICKABLE")
if bounds:
parts.append(f"bounds={bounds}")
elements.append(" | ".join(parts))
sig = f"PACKAGES: {', '.join(sorted(packages))}\n"
sig += "\n".join(elements[:50]) # Cap at 50 elements
return sig[:3000]
def _compute_situation_hash(self, compressed: str) -> str:
"""Deterministic hash for situation dedup."""
# Remove volatile parts (timestamps, counters) but keep structural identity
stable = re.sub(r'\d{2}:\d{2}', 'HH:MM', compressed)
stable = re.sub(r'Battery \d+ per cent', 'Battery NN per cent', stable)
return hashlib.sha256(stable.encode()).hexdigest()[:32]
def perceive(self, xml_dump: str) -> SituationType:
"""
Fast structural classification — NO LLM needed for perception.
Uses package names + structural markers to classify.
"""
if not xml_dump or not isinstance(xml_dump, str):
return SituationType.OBSTACLE_FOREIGN_APP
xml_lower = xml_dump.lower()
# ── DANGER: Action Blocked (must remain hardcoded — account safety) ──
blocked_markers = [
"try again later", "action blocked", "restrict certain activity",
"help us confirm you own", "confirm it's you",
"später erneut versuchen", "bestätige, dass du es bist",
"handlung blockiert", "eingeschränkt",
]
if any(m in xml_lower for m in blocked_markers):
return SituationType.DANGER_ACTION_BLOCKED
# ── Hardware Guard: Screen Off / Locked ──
if not getattr(self.device.deviceV2, 'info', {}).get("screenOn", True):
logger.info("📱 [SAE Perceive] Screen is physically OFF.")
return SituationType.OBSTACLE_LOCKED_SCREEN
# ── Foreign App / System Dialog Detection (package-based) ──
# Extract ALL packages present in the dump
# Support both single and double quotes for package detection (robustness across uia2 versions and tests)
packages = set(re.findall(r'package=["\']([^"\']+)["\']', xml_dump))
app_id = getattr(self.device, 'app_id', 'com.instagram.android')
# ── System Dialog Detection (BEFORE foreign app — system dialogs overlay Instagram) ──
system_packages = {'com.android.permissioncontroller', 'com.android.settings',
'com.google.android.packageinstaller'}
if system_packages & packages:
return SituationType.OBSTACLE_SYSTEM
# If Instagram package is not present AT ALL, we're in a foreign app
if app_id not in packages:
# Exception: system UI overlay is normal (status bar)
non_system = packages - {'com.android.systemui', 'android'}
if non_system:
logger.info(f"🔍 [SAE Perceive] Foreign app detected: {non_system}")
return SituationType.OBSTACLE_FOREIGN_APP
# If only systemui is present, we might be on a lock screen, notification shade, or recent apps
lock_markers = ['keyguard', 'lock_icon', 'emergency_call_button', 'kg_']
if any(m in xml_lower for m in lock_markers):
logger.info("📱 [SAE Perceive] Lock screen markers detected in SystemUI.")
return SituationType.OBSTACLE_LOCKED_SCREEN
return SituationType.OBSTACLE_FOREIGN_APP
# ── Modal/Obstacle Detection (structural, not ID-based) ──
# Instead of checking specific IDs, we check STRUCTURAL patterns:
# A modal is any overlay that has clickable elements AND covers main content
try:
clean = re.sub(r'<\?xml.*?\?>', '', xml_dump).strip()
root = ET.fromstring(clean)
# Find all top-level FrameLayouts from the Instagram package
ig_frames = []
for elem in root.iter('node'):
if elem.get('package') == app_id:
ig_frames.append(elem)
break # Get the root Instagram frame
if ig_frames:
ig_root = ig_frames[0]
# Walk the tree and look for overlay patterns:
# - FrameLayout children that overlap with the main content
# - Nodes with "dialog", "sheet", "modal", "overlay" in their resource-id
# - Nodes with dismiss/close/cancel/not now in text
for elem in ig_root.iter('node'):
rid = elem.get('resource-id', '').lower()
# Structural modal detection — ANY container with these words
if any(kw in rid for kw in ['dialog', 'sheet', 'modal', 'overlay', 'survey', 'interstitial', 'popup']):
# Check if it has actual content (not an empty container)
children = list(elem)
if len(children) > 0:
logger.info(f"🔍 [SAE Perceive] Modal/overlay detected via structural scan: {rid}")
return SituationType.OBSTACLE_MODAL
except Exception:
pass
return SituationType.NORMAL
# ──────────────────────────────────────────────
# 2. PLAN: AI-driven escape strategy
# ──────────────────────────────────────────────
def _plan_escape_via_structure(self, xml_dump: str, situation_type: SituationType, failed_this_session: set = None) -> EscapeAction:
"""
Unified structural escape planning.
Scans for ALL potential dismissal candidates (buttons or BACK) and scores them.
"""
if failed_this_session is None:
failed_this_session = set()
try:
clean = re.sub(r'<\?xml.*?\?>', '', xml_dump).strip()
root = ET.fromstring(clean)
except Exception:
return EscapeAction("back", reason="XML parse failed, pressing BACK as fallback")
# ── EXTREME PRIORITY: Force foreground if foreign app ──
if situation_type == SituationType.OBSTACLE_FOREIGN_APP:
return EscapeAction("app_start", reason="Foreign app detected, forcing Instagram to foreground")
# ── EXTREME PRIORITY: Unlock if locked ──
if situation_type == SituationType.OBSTACLE_LOCKED_SCREEN:
return EscapeAction("unlock", reason="Hardware condition: Device lock screen detected")
# ── UNIFIED SCAN ──
dismiss_text_keywords = [
'not now', 'cancel', 'dismiss', 'skip', 'deny', 'don\'t allow',
'no thanks', 'nicht jetzt', 'abbrechen', 'schließen',
'überspringen', 'ablehnen', 'nein danke', 'später',
'maybe later', 'vielleicht später', 'close', 'done',
]
dangerous_id_patterns = [
'follow', 'unfollow', 'mute', 'block', 'report',
'restrict', 'hide', 'favorite', 'close_friend',
'share', 'send', 'delete', 'archive', 'confirm',
]
candidates = []
# 1. Add "BACK" as a baseline candidate
back_key = "back:0,0"
if back_key not in failed_this_session:
# We don't add BACK for SYSTEM popups initially as it's often ignored
if situation_type == SituationType.OBSTACLE_MODAL:
candidates.append(EscapeAction("back", reason="Safest method: Try BACK first for modals"))
elif situation_type != SituationType.OBSTACLE_SYSTEM:
candidates.append(EscapeAction("back", reason="Generic BACK fallback candidate"))
# 2. Add clickable buttons from the XML
for elem in root.iter('node'):
if elem.get('clickable', 'false') != 'true':
continue
text = elem.get('text', '').strip().lower()
desc = elem.get('content-desc', '').strip().lower()
rid = elem.get('resource-id', '').strip().lower()
bounds = elem.get('bounds', '')
# Safety Guards
if any(dp in rid for dp in dangerous_id_patterns):
continue
match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds)
if not match:
continue
l, t, r, b = map(int, match.groups())
cx, cy = (l + r) // 2, (t + b) // 2
if f"click:{cx},{cy}" in failed_this_session:
continue
# Check for dismissal intent in text/desc
searchable = f"{text} {desc}"
if any(kw in searchable for kw in dismiss_text_keywords):
candidates.append(EscapeAction(
"click", cx, cy,
reason=f"Found explicit dismiss button: '{text or desc}'",
resource_id=rid
))
if not candidates:
logger.warning("🔍 [SAE Plan] No candidates found in structural scan!")
return EscapeAction("back", reason="No candidates found, attempting final BACK press as a last resort")
# 3. Score candidates to pick the best move
# Priority: -1 (Highest) -> 5 (Lowest)
def get_priority(ea):
# BACK fallback
if ea.action_type == "back":
# For modals, BACK is the standard "safe" way out and must be tried first
if situation_type == SituationType.OBSTACLE_MODAL:
return -1
return 4
if ea.action_type == "click":
r = ea.reason.lower()
# Explicit denials (High priority)
if any(k in r for k in ['not now', 'cancel', 'deny', 'don\'t allow', 'dismiss']):
return 0
# Generic close (Medium-High)
if any(k in r for k in ['close', 'schließen', 'skip', 'done']):
return 1
return 3
return 5
for c in candidates:
logger.debug(f"🔍 [SAE Plan] Candidate: type={c.action_type} reason='{c.reason}' priority={get_priority(c)}")
candidates.sort(key=get_priority)
return candidates[0]
def _plan_escape_via_llm(self, xml_dump: str, compressed: str, situation_type: SituationType) -> Optional[EscapeAction]:
"""
LLM-powered escape planning for situations where structural scan fails.
Called ONLY when recall AND structural planning both miss.
"""
from GramAddict.core.llm_provider import query_llm
from GramAddict.core.config import Config
try:
args = Config().args
model = getattr(args, "ai_fallback_model", "llama3.2:1b")
url = getattr(args, "ai_fallback_url", "http://localhost:11434/api/generate")
except Exception:
model = "llama3.2:1b"
url = "http://localhost:11434/api/generate"
system_prompt = (
"You are an Android UI navigation agent. Your job is to escape obstacles "
"(dialogs, modals, foreign apps, system popups) and return to Instagram. "
"Analyze the screen content and return a JSON escape action.\n\n"
"Rules:\n"
"- If you see a dismiss/close/cancel/skip/not now button, click it\n"
"- If you see a foreign app (not Instagram), press BACK\n"
"- If nothing else works, suggest 'app_start' to force-reopen Instagram\n"
"- NEVER click 'OK'/'Confirm'/'Accept' on surveys or prompts\n"
"- Return ONLY valid JSON: {\"action\": \"click\"|\"back\"|\"app_start\", \"x\": N, \"y\": N, \"reason\": \"...\"}"
)
user_prompt = (
f"Situation type: {situation_type.value}\n\n"
f"Screen content:\n{compressed}\n\n"
f"What action should I take to clear this obstacle and return to Instagram? Return JSON only."
)
try:
resp = query_llm(url=url, model=model, prompt=user_prompt, system=system_prompt,
format_json=True, timeout=30, max_tokens=100, temperature=0.0)
if resp and "response" in resp:
import json
data = json.loads(resp["response"])
return EscapeAction(
action_type=data.get("action", "back"),
x=int(data.get("x", 0)),
y=int(data.get("y", 0)),
reason=data.get("reason", "LLM-planned escape")
)
except Exception as e:
logger.warning(f"🧠 [SAE] LLM escape planning failed: {e}")
return EscapeAction("back", reason="LLM planning failed, defaulting to BACK")
# ──────────────────────────────────────────────
# 3. EXECUTE & VERIFY
# ──────────────────────────────────────────────
def _execute_escape(self, action: EscapeAction):
"""Execute a single escape action."""
if action.action_type == "click":
logger.info(f"👆 [SAE Act] Clicking ({action.x}, {action.y}): {action.reason}")
self.device.deviceV2.click(action.x, action.y) # Native click for safety (no human_click edge risks)
random_sleep(0.8, 1.5)
elif action.action_type == "back":
logger.info(f"⬅️ [SAE Act] Pressing BACK: {action.reason}")
self.device.deviceV2.press("back")
random_sleep(0.8, 1.5)
elif action.action_type == "unlock":
logger.info(f"🔓 [SAE Act] Unlocking device: {action.reason}")
self.device.deviceV2.unlock()
random_sleep(1.0, 2.0)
app_id = getattr(self.device, 'app_id', 'com.instagram.android')
self.device.deviceV2.app_start(app_id, use_monkey=True)
random_sleep(1.5, 2.5)
elif action.action_type == "app_start":
logger.info(f"🚀 [SAE Act] Force-starting app: {action.reason}")
app_id = getattr(self.device, 'app_id', 'com.instagram.android')
self.device.deviceV2.app_start(app_id, use_monkey=True)
random_sleep(2.0, 3.5)
elif action.action_type == "home_then_app":
logger.info(f"🏠 [SAE Act] HOME → App Start: {action.reason}")
self.device.deviceV2.press("home")
random_sleep(0.5, 1.0)
app_id = getattr(self.device, 'app_id', 'com.instagram.android')
self.device.deviceV2.app_start(app_id, use_monkey=True)
random_sleep(2.0, 3.5)
# ──────────────────────────────────────────────
# 4. MAIN ENTRY POINT: ensure_clear_screen()
# ──────────────────────────────────────────────
def ensure_clear_screen(self, max_attempts: int = 7, initial_xml: str = None) -> bool:
"""
The main autonomous loop. Called before every navigation action.
Perceives → Recalls → Plans → Acts → Verifies → Learns.
Returns True if an obstacle was successfully cleared, False if already clear or failed.
"""
from GramAddict.core.exceptions import ActionBlockedError
failed_this_session = set()
cleared_something = False
for attempt in range(max_attempts):
# ── PERCEIVE ──
if attempt == 0 and initial_xml:
xml_dump = initial_xml
else:
xml_dump = self.device.dump_hierarchy()
situation = self.perceive(xml_dump)
# ── CLEAR: Nothing to do ──
if situation == SituationType.NORMAL:
if attempt > 0:
logger.info(f"✅ [SAE] Screen cleared after {attempt} attempt(s)")
self._consecutive_failures = 0
return True
# ── DANGER: Account safety — hard stop ──
if situation == SituationType.DANGER_ACTION_BLOCKED:
logger.error("🚫 [SAE CRITICAL] Instagram Action Block detected! Halting to protect account.")
raise ActionBlockedError("Instagram action block detected by SAE.")
logger.warning(
f"🔍 [SAE] Obstacle detected: {situation.value} (attempt {attempt + 1}/{max_attempts})"
)
# ── COMPRESS for memory lookup ──
compressed = self._compress_xml(xml_dump)
# ── RECALL from memory ──
recalled = self.episodes.recall(compressed)
if recalled:
recalled_key = f"{recalled.get('action_type', '')}:{recalled.get('x', 0)},{recalled.get('y', 0)}"
if recalled_key not in failed_this_session:
action = EscapeAction.from_dict(recalled)
logger.info(f"🧠 [SAE] Using recalled strategy: {action.reason}")
else:
logger.info(f"🧠 [SAE] Recalled strategy already failed this session. Using structural planning.")
recalled = None
if not recalled:
if attempt < 3:
action = self._plan_escape_via_structure(xml_dump, situation, failed_this_session)
elif attempt < 5:
logger.info("🧠 [SAE] Escalating to LLM-assisted escape planning...")
action = self._plan_escape_via_llm(xml_dump, compressed, situation)
elif attempt == 5:
action = EscapeAction("app_start", reason=f"Escalation level 6: force app restart after {attempt} failed attempts")
else:
action = EscapeAction("home_then_app", reason=f"Nuclear escalation: HOME + app_start after {attempt} failed attempts")
# ── EXECUTE ──
self._execute_escape(action)
cleared_something = True
# ── VERIFY ──
post_xml = self.device.dump_hierarchy()
post_situation = self.perceive(post_xml)
success = (post_situation == SituationType.NORMAL)
# ── LEARN ──
self.episodes.learn(compressed, action, success)
if success:
logger.info(f"✅ [SAE] Obstacle cleared! Strategy '{action.reason}' worked. Stored for future recall.")
self._consecutive_failures = 0
return True
else:
action_key = f"{action.action_type}:{action.x},{action.y}"
failed_this_session.add(action_key)
logger.warning(
f"⚠️ [SAE] Escape attempt {attempt + 1} failed ('{action.reason}'). Trying next strategy..."
)
self._consecutive_failures += 1
logger.error(f"❌ [SAE] UNRECOVERABLE: Failed to clear screen after {max_attempts} attempts")
return False
def recover_to_app(self) -> bool:
"""
Called when the Perimeter Guard detects we're in a foreign app.
Uses the full SAE loop to get back.
"""
logger.warning("🚨 [SAE] Foreign app takeover detected. Initiating autonomous recovery...")
return self.ensure_clear_screen(max_attempts=5)
def is_instagram_foreground(self, xml_dump: str = None) -> bool:
"""Quick check: is Instagram the primary app on screen?"""
if xml_dump is None:
xml_dump = self.device.dump_hierarchy()
situation = self.perceive(xml_dump)
return situation == SituationType.NORMAL

633
GramAddict/core/telepathic_engine.py
View File

@@ -15,8 +15,8 @@ logger = logging.getLogger(__name__)
# ── Screen Zone Constants (fraction of screen height) ──
# Used for positional sanity checking instead of hardcoded resource-IDs.
STATUS_BAR_ZONE = 0.04 # Top 4% = Android status bar (wifi, battery, clock)
NAV_BAR_ZONE = 0.94 # Bottom 6% = Android nav bar / Instagram bottom tabs
STATUS_BAR_ZONE = 0.10 # Top 10% = Android status bar (increased to prevent hallucinations)
NAV_BAR_ZONE = 0.90 # Bottom 10% = Android nav bar (consistent with tab enforcement)
MAX_BUTTON_AREA = 150000 # Buttons/icons should be smaller than this (px²)
MAX_CONTAINER_AREA = 500000 # Anything above this is a full-screen container
@@ -27,13 +27,13 @@ BLACKLIST_FILE = "telepathic_blacklist.json"
class TelepathicEngine:
"""
Project Singularity V9: The Self-Learning Telepathic UI Engine
The Self-Learning Telepathic UI Engine
Completely replaces static Locators (XPath/Regex).
Transforms UI Nodes into natural language semantics, generates vector embeddings,
and returns the node mathematically closest to the target intent.
V9 Philosophy: ZERO hardcoded Instagram IDs.
Philosophy: ZERO hardcoded Instagram IDs.
Instead of maintaining brittle ID lists, the engine uses:
1. Structural heuristics (size, position, element class) — app-agnostic
2. Post-click verification — caller confirms if the click worked
@@ -175,6 +175,7 @@ class TelepathicEngine:
"raw_bounds": bounds_str,
"resource_id": res_id,
"class_name": class_name,
"naf": attrib.get('NAF', 'false').lower() == 'true',
"selected": attrib.get('selected', 'false').lower() == 'true',
"original_attribs": {"text": text, "desc": content_desc}
}
@@ -199,11 +200,72 @@ class TelepathicEngine:
def _compute_quick_score(self, intent: str, semantic: str) -> float:
"""Helper for legacy _extract_semantic_nodes filtering."""
intent_words = set(intent.lower().replace("_", " ").split())
semantic_words = set(semantic.lower().replace("_", " ").split())
clean_intent = re.sub(r'[^\w\s]', ' ', intent.lower().replace("_", " "))
clean_semantic = re.sub(r'[^\w\s]', ' ', semantic.lower().replace("_", " "))
intent_words = set(clean_intent.split())
semantic_words = set(clean_semantic.split())
common = intent_words.intersection(semantic_words)
return len(common) / len(intent_words) if intent_words else 0.0
# ──────────────────────────────────────────────
# Forbidden Action Guard (NEVER click these)
# ──────────────────────────────────────────────
# These are elements the bot must NEVER interact with, regardless of
# what the VLM or any heuristic says. They trigger side-effectful actions
# like creating content, going live, modifying account, etc.
# Pattern-matched against text, content-desc, AND resource-id (lowered).
FORBIDDEN_ACTIONS = [
# ── Content Creation (absolute red line) ──
'add to story', 'create story', 'your story', 'neue story',
'story erstellen', 'go live', 'live gehen',
'create post', 'beitrag erstellen', 'neuer beitrag',
'create reel', 'reel erstellen',
'camera', 'kamera',
# ── Account Modification ──
'edit profile', 'profil bearbeiten',
'switch account', 'konto wechseln',
'log out', 'abmelden', 'ausloggen',
'delete account', 'konto löschen',
# ── Dangerous Social Actions ──
'close friend', 'enge freunde',
'block', 'blockieren',
'report', 'melden',
'restrict', 'einschränken',
# ── Shopping/Payment ──
'checkout', 'buy now', 'purchase', 'jetzt kaufen',
'zur kasse', 'bezahlen',
]
# Resource-ID fragments that indicate forbidden elements
FORBIDDEN_ID_FRAGMENTS = [
'story_create', 'story_camera', 'reel_camera', 'camera_button',
'creation_tab', 'live_button', 'go_live',
'close_friend', 'close_friends',
'reel_empty_badge', # This is the "Add to story" badge that caused the real-world bug
]
def _is_forbidden_action(self, node: dict) -> bool:
"""
Returns True if this node represents a FORBIDDEN action the bot must never trigger.
Checks text, content-desc, and resource-id against the forbidden lists.
This is the LAST LINE OF DEFENSE against hallucinated VLM targets.
"""
text = node.get("text", "").lower()
desc = node.get("description", "").lower()
res_id = node.get("resource_id", "").lower()
semantic = node.get("semantic_string", "").lower()
searchable = f"{text} {desc} {res_id} {semantic}"
for forbidden in self.FORBIDDEN_ACTIONS:
if forbidden in searchable:
return True
for frag in self.FORBIDDEN_ID_FRAGMENTS:
if frag in res_id:
return True
return False
# ──────────────────────────────────────────────
# Structural Sanity (app-agnostic, no hardcoded IDs)
# ──────────────────────────────────────────────
@@ -229,8 +291,13 @@ class TelepathicEngine:
if node.get("area", 0) > MAX_CONTAINER_AREA and not is_media_intent:
return False
# 2. Reject nodes in the Android status bar zone (top 4%)
if node.get("y", 0) < screen_height * STATUS_BAR_ZONE:
# 2. Reject nodes in the Android status bar zone (top 10%)
# UNLESS they are explicitly known top-bar interaction elements
top_safe_ids = ["row_feed_photo_profile_name", "media_header_user", "action_bar", "secondary_label"]
res_id = node.get("resource_id", "").lower()
top_bypass = any(k in res_id for k in top_safe_ids)
if node.get("y", 0) < screen_height * STATUS_BAR_ZONE and not top_bypass:
return False
# 3. Reject nodes in the Navigation Bar zone (bottom 6% - adjusted for accuracy)
@@ -243,7 +310,7 @@ class TelepathicEngine:
is_modal_intent = any(k in low_intent for k in modal_keywords)
# Resource-ID bypass for profile header elements that sit low
safe_ids = ["following", "follower", "post_count", "button_edit_profile", "button_share_profile"]
safe_ids = ["following", "follower", "post_count", "button_edit_profile", "button_share_profile", "direct_tab"]
res_id = node.get("resource_id", "").lower()
id_bypass = any(k in res_id for k in safe_ids)
@@ -251,9 +318,18 @@ class TelepathicEngine:
if node.get("y", 0) > threshold and not (is_nav_intent or is_modal_intent or id_bypass):
# Not an AI error—this is the deterministic prep-filter culling the NavBar before VLM logic.
logger.debug(f"🛡️ [Pre-LLM Pruning] Ignored navbar/overlay element (y={node.get('y')}) to prevent VLM hallucination.")
return False
# STRICT NAVIGATION TAB ENFORCEMENT
# Navigation tabs MUST be at the bottom (>= 0.92 of screen height).
# We reject any navigation tab hallucinated in the middle of the screen.
if is_nav_intent and node.get("y", 0) < screen_height * 0.92:
# We must be careful: intent could be "navigate to profile" which means click username
# So ONLY block if the intent explicitly says "tab".
if "tab" in low_intent:
# Silently filter non-bottom elements for navigation intents to prevent log spam
return False
# 4. Reject own profile/story if the intent is not explicitly looking for it.
# Intuitively, "profile picture avatar story ring" means "click a user's story".
# If we are looking for a story/profile, we must NOT click our OWN story.
@@ -261,13 +337,11 @@ class TelepathicEngine:
if not is_targeting_own_profile:
semantic_lower = node.get("semantic_string", "").lower()
if "your story" in semantic_lower:
logger.debug(f"🛡️ [Structural Guard] Rejecting own story overlay for intent '{intent_description}': {node['semantic_string']}")
return False
bot_username = self._get_current_username()
if bot_username and bot_username in semantic_lower:
# Rejecting bot's own username to prevent clicking itself (e.g. "marisaundmarc's story, 0 of 27")
logger.debug(f"🛡️ [Structural Guard] Rejecting own username '{bot_username}' for intent '{intent_description}': {node['semantic_string']}")
# Rejecting bot's own username to prevent clicking itself
return False
# 5. Language-Agnostic Modal/Menu Guard
# Prevent clicks on items inside dialogs, bottom sheets, or context menus
@@ -279,12 +353,22 @@ class TelepathicEngine:
# If the intent doesn't sound like it wants a menu...
wants_menu_intent = any(k in low_intent for k in ["menu", "option", "more", "dismiss", "cancel", "modal"])
if is_menu_node and not wants_menu_intent:
logger.debug(f"🛡️ [Modal Guard] Rejecting menu/dialog item for non-menu intent '{intent_description}': {node['semantic_string']}")
return False
# 6. Reject nodes with zero area (invisible)
if node.get("area", 0) == 0:
return False
# 7. FORBIDDEN ACTION GUARD
# The bot must NEVER click elements that create content, modify the account,
# or trigger irreversible actions. This is the pre-filter level —
# VLM will never even see these nodes.
if self._is_forbidden_action(node):
logger.debug(
f"🛡️ [Forbidden Guard] Blocking dangerous element for intent '{intent_description}': "
f"{node.get('semantic_string', 'N/A')}"
)
return False
return True
@@ -358,6 +442,29 @@ class TelepathicEngine:
if not intent_words:
return None
# Check for absolute trap/anomaly dismissal intent to bypass LLM parsing
intent_lower = intent_description.lower()
if "close" in intent_lower or "dismiss" in intent_lower or "escape" in intent_lower:
priority_keywords = ["done", "close", "cancel", "schließen", "abbrechen", "dismiss", "not now", "clear text"]
best_match = None
best_priority = 999
for n in nodes:
s = n.get("semantic_string", "").lower() + " " + n.get("resource_id", "").lower()
for i, k in enumerate(priority_keywords):
if k in s and i < best_priority:
best_priority = i
best_match = n
if best_match:
logger.info(f"⏭️ [Keyword Fast Path] Detected semantic escape hatch: '{best_match.get('semantic_string')}'")
return {
"x": best_match["x"],
"y": best_match["y"],
"score": 1.0,
"semantic": best_match.get("semantic_string", "Escape Hatch"),
"source": "keyword_fast_path"
}
# Expand known Instagram aliases to avoid sending UI basics to the LLM mappings
aliases = {
"reels": ["clips", "reel"],
@@ -379,13 +486,15 @@ class TelepathicEngine:
searchable = f"{sem} {rid} {desc_text} {node_text}"
# Count how many intent keywords appear in the node's text (including aliases)
# Using WORD BOUNDARY matching to prevent 'follow' → '5.107following' false positives
hits = 0
for w in intent_words:
if w in searchable:
# Word-boundary match: 'follow' must NOT match 'following' or '5107following'
if re.search(r'(?:^|[\s,._\-:])' + re.escape(w) + r'(?:$|[\s,._\-:!?])', searchable):
hits += 1
elif w in aliases:
for alias in aliases[w]:
if alias in searchable:
if re.search(r'(?:^|[\s,._\-:])' + re.escape(alias) + r'(?:$|[\s,._\-:!?])', searchable):
hits += 1
break
@@ -395,6 +504,13 @@ class TelepathicEngine:
# Score = ratio of intent keywords matched
score = hits / len(intent_words)
# ── Anti-confusion: reject stat counters for action intents ──
# 'follow button' intent should NOT match '5.107following' stat counter
if 'follow' in intent_words or 'like' in intent_words:
if re.search(r'\d+\s*(follow|like|post|comment)', searchable):
# This is a stat counter (e.g., '2.361 followers'), not an action button
score *= 0.3 # Heavy penalty
# Require at least 75% keyword overlap to avoid fatal false positives (e.g. 'post username' matching 'Send post')
if score >= 0.75:
scored.append((node, score))
@@ -460,30 +576,74 @@ class TelepathicEngine:
if "comments are turned off" in xml_lower or "comments on this post" in xml_lower or "kommentare sind deaktiviert" in xml_lower or "eingeschränkt" in xml_lower:
logger.info("⏭️ [Telepathic] Comments are disabled on this post. Skipping to prevent VLM hallucination.")
return {"x": None, "y": None, "score": 1.0, "semantic": "comments_disabled", "skip": True}
interactive_nodes = self._extract_semantic_nodes(xml_hierarchy)
if not interactive_nodes:
logger.debug("[TelepathicEngine] Screen contains no interactable semantic nodes.")
return None
# Guard against clicking 'Following' when we want to 'Follow'
if "follow" in intent_lower and "follower" not in intent_lower:
for n in interactive_nodes:
res_id = n.get("resource_id", "")
text_lower = (n.get("text", "") or n.get("content_desc", "")).lower().strip()
# Check absolute ID
if "profile_header_follow_button" in res_id:
if any(state in text_lower for state in ["following", "gefolgt", "angefragt", "requested", "abonniert"]):
logger.info(f"✅ [Intent Guard] Goal '{intent_description}' fulfilled (Button says '{text_lower}'). Bailing click.")
return {"x": None, "y": None, "score": 1.0, "semantic": "already_followed", "skip": True}
# Check generic exact matches on standard toggle strings
elif text_lower in ["following", "gefolgt", "angefragt", "requested", "abonniert"]:
logger.info(f"✅ [Intent Guard] Goal '{intent_description}' fulfilled (Generic button '{text_lower}'). Bailing click.")
return {"x": None, "y": None, "score": 1.0, "semantic": "already_followed", "skip": True}
# Detect screen height for zone calculations
screen_height = 2400
if interactive_nodes:
max_y = max(n.get("y", 0) + n.get("height", 0) // 2 for n in interactive_nodes)
if max_y > 100:
if 2200 < max_y < 2600:
screen_height = max_y
else:
screen_height = int(max_y * 1.02)
if device and hasattr(device, "get_info"):
try:
screen_height = device.get_info().get("displayHeight", 2400)
except Exception:
pass
if screen_height == 2400 and interactive_nodes:
max_bounds_y = max((n.get("y", 0) + n.get("height", 0) // 2) for n in interactive_nodes)
if max_bounds_y > 2000:
screen_height = max_bounds_y
# ── Modal Guard ──
# If a bottom sheet or dialog is active, it likely obscures the main navigation tabs.
# We scan the raw XML to catch non-interactable modals (like those in Reels traps).
is_nav_intent = any(k in intent_lower for k in ["tab", "navigation", "search and explore", "reels", "profile", "home", "message"])
is_nav_intent = any(k in intent_lower for k in ["tab", "navigation", "reels tab", "profile tab", "home tab", "explore tab", "message tab"])
if is_nav_intent and self._is_modal_active(interactive_nodes, raw_xml_string=xml_hierarchy):
logger.warning(f"🛡️ [Modal Guard] A bottom sheet or dialog is blocking the screen. Refusing to seek nav-intent '{intent_description}'.")
return {"blocked_by_modal": True}
# ── DM Thread (Forbidden Zone) Guard ──
# If the bot is trapped inside a DM thread, it should NOT attempt to find
# profile-related targets (like the grid or follow button). This prevents the
# "Message-Hijacking" loop discovered in session 2026-04-17.
is_profile_seeking = any(k in intent_lower for k in ["profile grid", "follow button", "story ring", "grid item", "grid first post"])
is_dm_thread = any(k in xml_hierarchy for k in ["direct_thread_header", "message_list", "row_thread_composer_edittext"])
if is_dm_thread and is_profile_seeking:
logger.warning(f"🛡️ [DM Forbidden Zone] Refusing profile-intent '{intent_description}' inside a DM thread. Forcing navigation fallback.")
return {"blocked_by_dm_thread": True}
# ── Others Profile (Navigation Mislead) Guard ──
# In external profiles, the "Grid/Reels" tabs often mislead VLM into thinking
# they are the main navigation tabs if the bottom bar is suppressed.
is_others_profile = "profile_header_container" in xml_hierarchy or "row_profile_header" in xml_hierarchy
is_home_nav = any(k in intent_lower for k in ["tap home tab", "home feed index"])
if is_others_profile and is_home_nav:
# Check if the bottom bar components are actually present.
# Usually: self_profile_tab, home_tab, explore_tab
has_nav_bar = "tab_bar" in xml_hierarchy or "home_tab" in xml_hierarchy or "reels_tab" in xml_hierarchy
if not has_nav_bar:
logger.warning(f"🛡️ [Profile Nav Guard] Detected 'OthersProfile' with MISSING bottom bar. Blocking hallucination-prone intent '{intent_description}'.")
return {"blocked_by_others_profile_trap": True}
# Pre-filter: Remove structurally implausible nodes and blacklisted mappings
viable_nodes = []
for node in interactive_nodes:
@@ -509,39 +669,17 @@ class TelepathicEngine:
logger.warning(f"⚠️ [Context Guard] Not in target app! Aborting AI lookup for '{intent_description}'.")
return None
# ── Stage 1: Positive Memory Cache (CONFIRMED past clicks) ──
self._memory = self._load_json(MEMORY_FILE) # Reload for freshness
if intent_description in self._memory:
known_semantics = self._memory[intent_description]
for n in viable_nodes:
if n["semantic_string"] in known_semantics:
# Prevent un-liking
if "like" in intent_description.lower() and re.search(
r"\b(liked|gefällt mir nicht mehr)\b",
n["semantic_string"].lower()
):
logger.info("⏭️ [Memory] Post is already Liked. Skipping tap to prevent un-liking.")
return {"x": None, "y": None, "score": 1.0, "semantic": "already_liked", "skip": True}
# Prevent un-following
if "follow" in intent_description.lower() and re.search(
r"\b(following|requested|folgst du|angefragt|gefolgt)\b",
n["semantic_string"].lower()
):
logger.info("⏭️ [Memory] User is already Followed/Requested. Skipping tap to prevent opening the Favorites menu.")
return {"x": None, "y": None, "score": 1.0, "semantic": "already_followed", "skip": True}
logger.debug(f"🧠 [Confirmed Memory] Instant recall: '{intent_description}' → {n['semantic_string']}")
self._track_click(intent_description, n)
return {
"x": n["x"],
"y": n["y"],
"score": 1.0,
"semantic": f"Memory Match: {n['semantic_string']}",
"source": "memory"
}
# ══════════════════════════════════════════════════════════════
# ── Stage 0: DETERMINISTIC Core Navigation Fast Path ──
# THIS MUST BE FIRST. It uses LIVE resource-IDs from the CURRENT
# XML dump. Memory can be poisoned by past notification overlays
# that shifted coordinates. Resource-IDs are ground truth.
# ══════════════════════════════════════════════════════════════
core_nav_result = self._core_navigation_fast_path(intent_description, viable_nodes)
if core_nav_result:
return core_nav_result
# ── Stage 1.25: Structural Grid Fast Path ──
# ── Stage 0.5: Structural Grid Fast Path ──
# Direct resource-ID + spatial sorting for grid navigation intents.
# This bypasses keyword/vector/VLM entirely — O(n) deterministic.
low_intent = intent_description.lower()
@@ -552,6 +690,60 @@ class TelepathicEngine:
if grid_result:
return grid_result
# ── Stage 1: Positive Memory Cache (CONFIRMED past clicks) ──
self._memory = self._load_json(MEMORY_FILE) # Reload for freshness
if intent_description in self._memory:
known_semantics = self._memory[intent_description]
for n in viable_nodes:
sem_str = n["semantic_string"]
# Check if this semantic string is in memory (handles both old list format and new dict format)
if isinstance(known_semantics, dict) and sem_str in known_semantics:
confidence = known_semantics[sem_str]
if confidence < 0.5:
continue # Stale, force LLM/Vector fallback
# Prevent un-liking
if "like" in intent_description.lower() and re.search(
r"\b(liked|gefällt mir nicht mehr)\b",
sem_str.lower()
):
logger.info("⏭️ [Memory] Post is already Liked. Skipping tap to prevent un-liking.")
return {"x": None, "y": None, "score": 1.0, "semantic": "already_liked", "skip": True}
# Prevent un-following
if "follow" in intent_description.lower() and re.search(
r"\b(following|requested|folgst du|angefragt|gefolgt)\b",
sem_str.lower()
):
logger.info("⏭️ [Memory] User is already Followed/Requested. Skipping tap to prevent opening the Favorites menu.")
return {"x": None, "y": None, "score": 1.0, "semantic": "already_followed", "skip": True}
logger.debug(f"🧠 [Confirmed Memory] Instant recall: '{intent_description}' → {sem_str} (Conf: {confidence:.2f})")
self._track_click(intent_description, n)
return {
"x": n["x"],
"y": n["y"],
"score": confidence,
"semantic": f"Memory Match: {sem_str}",
"source": "memory"
}
elif isinstance(known_semantics, list) and sem_str in known_semantics:
# Legacy fallback logic for old JSON list format
if "like" in intent_description.lower() and re.search(r"\b(liked|gefällt mir nicht mehr)\b", sem_str.lower()):
return {"x": None, "y": None, "score": 1.0, "semantic": "already_liked", "skip": True}
if "follow" in intent_description.lower() and re.search(r"\b(following|requested|folgst du|angefragt|gefolgt)\b", sem_str.lower()):
return {"x": None, "y": None, "score": 1.0, "semantic": "already_followed", "skip": True}
self._track_click(intent_description, n)
return {
"x": n["x"],
"y": n["y"],
"score": 1.0,
"semantic": f"Memory Match: {sem_str}",
"source": "memory"
}
# ── Stage 1.5: Deterministic Keyword Fast Path ──
fast_path_result = self._keyword_match_score(intent_description, viable_nodes)
if fast_path_result:
@@ -623,6 +815,97 @@ class TelepathicEngine:
# Click Tracking & Feedback Loop
# ──────────────────────────────────────────────
def evaluate_grid_visuals(self, device, persona_interests: list[str]) -> Optional[dict]:
"""
[Phase 2] High-fidelity grid evaluation.
Instead of clicking the first available post, uses vision to pick the best match
against configured persona interests.
"""
logger.info(f"👁️ [Vision Core] Analyzing grid aesthetics against niche interests: {persona_interests}...")
xml = device.dump_hierarchy()
nodes = self._parse_and_flatten(xml)
# Identify grid nodes (posts)
grid_nodes = [n for n in nodes if any(k in n.get("resource_id", "") for k in ["image_button", "grid_card_layout_container"])]
if not grid_nodes:
logger.warning("👁️ [Vision Core] No grid items found to evaluate. Falling back to default navigation.")
return None
# Sort them Top-to-Bottom, Left-to-Right to match indexing [0-8]
grid_nodes.sort(key=lambda n: (round(n["y"] / 5) * 5, n["x"]))
# Limit to the top 9 items (3x3) to keep context manageable for VLM
grid_nodes = grid_nodes[:9]
# Take a screenshot
try:
screenshot_b64 = device.get_screenshot_b64()
except Exception as e:
logger.error(f"👁️ [Vision Core] Failed to capture screenshot: {e}")
return None
# Format the nodes for the vision model context
simplified_nodes = []
for i, node in enumerate(grid_nodes):
simplified_nodes.append({
"index": i,
"bounds": [node["x1"], node["y1"], node["x2"], node["y2"]]
})
system_prompt = (
"You are an aesthetic evaluation agent for Instagram with a professional eye for niche alignment. "
"You are looking at a 3x3 grid of post thumbnails. "
"Your goal is to pick the image index [0-8] that BEST matches the provided niche interests."
)
user_prompt = (
f"Niche Interests: {', '.join(persona_interests)}\n\n"
f"Grid Elements (indices and bounding boxes):\n{json.dumps(simplified_nodes)}\n\n"
"Return a JSON object: {\"best_index\": number, \"reason\": \"brief explanation of why this image fits the niche\"}\n"
"If none fit, pick the most generic/high-quality one."
)
try:
from GramAddict.core.llm_provider import query_llm
args = device.args
model = getattr(args, "ai_telepathic_model", "llama3.2-vision")
url = getattr(args, "ai_telepathic_url", "http://localhost:11434/api/generate")
# Use a slightly higher temperature for aesthetic judging
resp_dict = query_llm(
url=url,
model=model,
prompt=user_prompt,
system=system_prompt,
images_b64=[screenshot_b64],
format_json=True,
temperature=0.4
)
if resp_dict and "response" in resp_dict:
from GramAddict.core.llm_provider import extract_json
clean_json = extract_json(resp_dict["response"])
if clean_json:
data = json.loads(clean_json)
idx = data.get("best_index")
if idx is not None and 0 <= idx < len(grid_nodes):
chosen = grid_nodes[idx]
logger.info(f"✅ [Vision Match] Cell {idx} chosen: {data.get('reason')}", extra={"color": f"{Fore.GREEN}"})
self._track_click(f"Visual Grid Selection ({idx})", chosen)
return {
"x": chosen["x"],
"y": chosen["y"],
"score": 0.99,
"semantic": f"Visual match {idx}: {data.get('reason')}",
"source": "vlm_grid"
}
except Exception as e:
logger.error(f"👁️ [Vision Core] Grid evaluation failed: {e}")
return None
def _grid_fast_path(self, intent_description: str, viable_nodes: list, skip_positions: set = None) -> Optional[dict]:
"""
Deterministic grid navigation: filters for image_button nodes,
@@ -634,12 +917,20 @@ class TelepathicEngine:
if skip_positions is None:
skip_positions = set()
grid_nodes = [n for n in viable_nodes if "image_button" in n.get("resource_id", "")]
grid_nodes = [n for n in viable_nodes if any(k in n.get("resource_id", "") for k in ["image_button", "grid_card_layout_container"])]
if not grid_nodes:
return None
# Sort by Y (topmost first), then X (leftmost first)
grid_nodes.sort(key=lambda n: (n["y"], n["x"]))
# Preference logic with rounding to group items clearly in the same row:
# 1. Round Y to nearest 5px to handle minor layout discrepancies
# 2. Non-NAF is better than NAF (accessibility friendly)
# 3. Containers (grid_card_layout_container) preferred over inner buttons
grid_nodes.sort(key=lambda n: (
round(n["y"] / 5) * 5,
n["x"],
n.get("naf", False), # False (0) is better than True (1)
-n["area"] # Larger area (containers) preferred among equal y/x
))
# Filter out previously-failed positions
for candidate in grid_nodes:
@@ -661,6 +952,78 @@ class TelepathicEngine:
logger.warning(f"⚠️ [Grid Fast-Path] All grid positions exhausted for '{intent_description}'. Falling through to VLM.")
return None
def _core_navigation_fast_path(self, intent_description: str, viable_nodes: list) -> Optional[dict]:
"""
Absolutely deterministic resource-ID targeting for core application navigation
(like direct messages or post usernames) to prevent VLM hallucination.
"""
low_intent = intent_description.lower()
# 1. Post Username (Feed Profile)
if low_intent in ["tap_post_username", "tap post username"]:
for n in viable_nodes:
res_id = n.get("resource_id", "")
if "row_feed_photo_profile_name" in res_id or "media_header_user" in res_id:
logger.info(f"⚡ [Core Nav Fast Path] Found explicit username mapping for '{intent_description}' -> '{res_id}'")
self._track_click(intent_description, n)
return {
"x": n["x"],
"y": n["y"],
"score": 1.0,
"semantic": n["semantic_string"],
"source": "core_nav"
}
# 2. Direct Message Inbox
if "message" in low_intent and "icon" in low_intent:
for n in viable_nodes:
res_id = n.get("resource_id", "")
if "action_bar" in res_id and "direct" in res_id:
logger.info(f"⚡ [Core Nav Fast Path] Found explicit DM Inbox action bar mapping for '{intent_description}' -> '{res_id}'")
self._track_click(intent_description, n)
return {
"x": n["x"],
"y": n["y"],
"score": 1.0,
"semantic": n["semantic_string"],
"source": "core_nav"
}
if "direct_tab" in res_id:
logger.info(f"⚡ [Core Nav Fast Path] Found explicit DM Tab mapping for '{intent_description}' -> '{res_id}'")
self._track_click(intent_description, n)
return {
"x": n["x"],
"y": n["y"],
"score": 1.0,
"semantic": n["semantic_string"],
"source": "core_nav"
}
# 3. Application Navigation Tabs
tab_mappings = {
"tap_home_tab": "feed_tab",
"tap home tab": "feed_tab",
"tap_explore_tab": "search_tab",
"tap explore tab": "search_tab",
"tap_reels_tab": "clips_tab",
"tap reels tab": "clips_tab",
"tap_profile_tab": "profile_tab",
"tap profile tab": "profile_tab"
}
if low_intent in tab_mappings:
target_res_id = tab_mappings[low_intent]
for n in viable_nodes:
if target_res_id in n.get("resource_id", "").lower():
logger.info(f"⚡ [Core Nav Fast Path] Found explicit Main Tab mapping for '{intent_description}' -> '{target_res_id}'")
self._track_click(intent_description, n)
return {
"x": n["x"],
"y": n["y"],
"score": 1.0,
"semantic": n["semantic_string"],
"source": "core_nav"
}
return None
def _track_click(self, intent: str, node: dict):
"""Records what we're about to click so confirm/reject can reference it."""
TelepathicEngine._last_click_context = {
@@ -689,13 +1052,18 @@ class TelepathicEngine:
actual_intent = intent or ctx["intent"]
sem = ctx["semantic_string"]
# Add to positive memory
# Add to positive memory with 100% confidence
if actual_intent not in self._memory:
self._memory[actual_intent] = []
if sem not in self._memory[actual_intent]:
self._memory[actual_intent].append(sem)
self._save_json(MEMORY_FILE, self._memory)
logger.debug(f"✅ [Confirmed Learning] Stored: '{actual_intent}' → '{sem}'")
self._memory[actual_intent] = {}
elif isinstance(self._memory[actual_intent], list):
# Migrate legacy list to new dict format
legacy_list = self._memory[actual_intent]
self._memory[actual_intent] = {k: 1.0 for k in legacy_list}
# Boost/Set confidence to 1.0
self._memory[actual_intent][sem] = 1.0
self._save_json(MEMORY_FILE, self._memory)
logger.debug(f"✅ [Confirmed Learning] Stored/Boosted: '{actual_intent}' → '{sem}' (Confidence: 1.0)")
# Remove from blacklist if it was there (rehabilitation)
if actual_intent in self._blacklist and sem in self._blacklist[actual_intent]:
@@ -721,7 +1089,11 @@ class TelepathicEngine:
# ── Anti-Poisoning Guard ──
# Structural UI elements (Home Tab, Like Button, etc.) should NEVER be globally blacklisted
# because they are essential for navigation and are unlikely to cause app-drift (only Ads do).
structural_intents = {"tap home tab", "tap reels tab", "tap explore tab", "tap newsfeed_tab", "tap like button", "tap comment_button", "tap share button"}
structural_intents = {
"tap home tab", "tap reels tab", "tap profile tab", "tap direct message icon inbox",
"tap explore tab", "tap newsfeed_tab", "tap like button", "tap comment button",
"tap share button", "tap story ring avatar"
}
has_text = bool(re.search(r'(?<!\w)text:', sem.lower()))
has_desc = bool(re.search(r'(?<!\w)description:', sem.lower()))
@@ -743,15 +1115,25 @@ class TelepathicEngine:
self._save_json(BLACKLIST_FILE, self._blacklist)
logger.warning(f"🚫 [Negative Learning] Blacklisted: '{actual_intent}' → '{sem}'")
# ── Always Purge Positive Cache ──
# Even if it's generic, if it failed for THIS specific intent, we MUST unlearn
# the positive memory cache so we don't infinitely retry it.
# Remove from positive memory if it was cached
if actual_intent in self._memory and sem in self._memory[actual_intent]:
self._memory[actual_intent].remove(sem)
self._save_json(MEMORY_FILE, self._memory)
logger.warning(f"🗑️ [Memory Purge] Removed bad mapping from memory: '{actual_intent}' → '{sem}'")
# ── Confidence Decay (The Unlearning Mechanism) ──
# Reduce confidence by 30%. If < 50%, purge aggressively.
if actual_intent in self._memory:
entry = self._memory[actual_intent]
# Convert legacy format
if isinstance(entry, list):
self._memory[actual_intent] = {k: 1.0 for k in entry}
entry = self._memory[actual_intent]
if sem in entry:
entry[sem] -= 0.30
logger.warning(f"📉 [Unlearning] Mapping failed. Dropping confidence for '{sem}' to {entry[sem]:.2f}")
if entry[sem] < 0.50:
del entry[sem]
self._save_json(MEMORY_FILE, self._memory)
logger.warning(f"🗑️ [Memory Purge] Confidence fell below 50%. Actively deleted mapping '{actual_intent}' → '{sem}'")
else:
self._save_json(MEMORY_FILE, self._memory)
TelepathicEngine._last_click_context = None
@@ -761,9 +1143,9 @@ class TelepathicEngine:
Inspects the post-click XML for semantic markers that prove the intent worked.
"""
ctx = TelepathicEngine._last_click_context
if not ctx:
return True # No context to verify against
# If no context is set, we can't do positional consistency,
# but we MUST still enforce intent-specific markers below.
# 1. Positional Consistency (Atomic Guard)
# If the screen changed so much that NO elements are near the original click,
# it might be a context-switch (navigation success).
@@ -854,23 +1236,45 @@ class TelepathicEngine:
logger.debug("👁️ [Vision Inference] Capturing screen for spatial understanding...")
img_obj = device.screenshot()
if img_obj:
import io
if hasattr(img_obj, "save"):
import io
buf = io.BytesIO()
img_obj.save(buf, format='JPEG')
raw_bytes = buf.getvalue()
else:
elif isinstance(img_obj, bytes):
raw_bytes = img_obj
b64_str = base64.b64encode(raw_bytes).decode('utf-8')
images_payload = [b64_str]
else:
try:
raw_bytes = bytes(img_obj)
except Exception:
logger.warning(f"👁️ [Vision Inference] Could not convert screenshot object {type(img_obj)} to bytes.")
raw_bytes = None
if raw_bytes:
b64_str = base64.b64encode(raw_bytes).decode('utf-8')
images_payload = [b64_str]
except Exception as e:
logger.warning(f"⚠️ [Vision Inference] Failed to capture or encode screenshot: {e}")
# Expand context to 150 nodes to harness local 8k-32k models natively
# ── Instant Intent Fulfillment (Pre-VLM) ──
# If we are looking for 'follow' and we see 'Following', 'Requested', or 'Follow back',
# we consider the intent ALREADY FULFILLED and skip to avoid opening menus.
intent_lower = intent.lower()
if any(k in intent_lower for k in ["follow"]):
for i, node in enumerate(nodes[:50]):
text_lower = (node.get("text", "") or node.get("content_desc", "")).lower()
if any(x in text_lower for x in ["following", "gefolgt", "angefragt", "requested", "follow back", "zurückfolgen"]):
logger.info(f"✅ [Intent Guard] Goal '{intent}' already fulfilled by node {i} ('{text_lower}'). Bailing click.")
return {"index": i, "skip": True, "reason": "Already fulfilled"}
# ── VLM Context Optimization (Top 30 scoring elements only to prevent Timeouts) ──
candidates = [(i, n) for i, n in enumerate(nodes)]
candidates.sort(key=lambda x: x[1].get("score", 0.0), reverse=True)
simplified_nodes = []
for i, n in enumerate(nodes[:150]):
for orig_idx, n in candidates[:30]:
simplified_nodes.append({
"index": i,
"index": orig_idx,
"bounds": n["raw_bounds"],
"semantic": n["semantic_string"]
})
@@ -917,10 +1321,13 @@ class TelepathicEngine:
"Rules:\n"
"- Pick the SMALLEST, most specific button or icon\n"
"- NEVER pick large containers, full-screen views, or recycler views\n"
"- NEVER pick system icons (wifi, battery, status bar, clock)\n"
"- NEVER pick system icons (wifi, battery, status bar, clock, notifications)\n"
"- IGNORE BOTTOM NAVIGATION TABS (Home, Search, Reels, Message, Profile) if the intent is to interact with a post or comment.\n"
"- SPATIAL GUARD: Elements in the TOP 10% (Y < 240) are USUALLY part of the system status bar. ELEMENT MUST BE BELOW THIS UNLESS IT IS A STORY CIRCLE.\n"
"- SPATIAL GUARD: Elements in the BOTTOM 10% (Y > 2160) are USUALLY part of the navigation bar. ELEMENT MUST BE ABOVE THIS UNLESS IT IS A NAVIGATION TAB.\n"
"- A 'Comment input' is usually an EditText or a region near the bottom but ABOVE the navigation bar.\n"
"- A 'story tray' or 'story ring' is ALWAYS located at the very TOP of the screen (low Y coordinates).\n"
"- NAVIGATION TABS (Home, Explore, Reels, News, Profile) are ALWAYS in the BOTTOM zone (Y coordinates > 0.90 of screen height).\n"
"Return: {\"index\": number, \"reason\": \"...\"}"
)
@@ -946,8 +1353,8 @@ class TelepathicEngine:
# ── Structural Guard 1: Size ──
is_media_intent = any(k in intent.lower() for k in ["video", "photo", "reel", "media", "post"])
if match.get("area", 0) > MAX_CONTAINER_AREA and not is_media_intent:
logger.error(
f"❌ [Structural Guard] VLM selected oversized element "
logger.warning(
f"🛡️ [Structural Guard] VLM selected oversized element "
f"({match.get('width')}x{match.get('height')}): {match['semantic_string']}. REJECTING."
)
dump_ui_state(device, "vlm_hallucination", {
@@ -960,31 +1367,34 @@ class TelepathicEngine:
# ── Structural Guard 2: Position (status / nav bar / tab zones) ──
if match.get("y", 0) < screen_height * STATUS_BAR_ZONE:
logger.error(f"❌ [Structural Guard] VLM selected element in status bar zone: {match['semantic_string']}. REJECTING.")
logger.warning(f"🛡️ [Structural Guard] VLM selected element in status bar zone: {match['semantic_string']}. REJECTING.")
return None
is_nav_intent = any(k in intent.lower() for k in ["tab", "navigation", "search and explore", "reels", "profile", "home", "message"])
is_nav_intent = any(k in intent.lower() for k in ["tab", "navigation", "reels tab", "profile tab", "home tab", "message tab"])
# NAVIGATION TAB ENFORCEMENT:
# Real navigation tabs (Home, Search, Reels, Store, Profile) are ALWAYS in the bottom zone.
# If the bot is looking for a tab, forbid results that are too high up (likely hallucinations on comments/feed).
if is_nav_intent:
# Tab intents MUST be in the bottom 10% (0.90) of the screen
if match.get("y", 0) < screen_height * 0.90:
logger.error(
f"❌ [Structural Guard] VLM hallucinated a navigation tab '{intent}' "
f"in the middle of the screen (Y={match.get('y')} | Screen={screen_height}). REJECTING."
# Navigation tabs (Home, Search, Reels, News, Profile) are strictly at the bottom.
# On many devices with virtual buttons, they are roughly at 0.94 - 0.98.
# On full-screen gesture devices, they might be slightly higher.
# We use 0.92 as a firm structural boundary.
if match.get("y", 0) < screen_height * 0.92:
logger.warning(
f"🛡️ [Structural Guard] VLM hallucinated a navigation tab '{intent}' "
f"in the middle/top of the screen (Y={match.get('y')} | Screen={screen_height}). REJECTING."
)
return None
if match.get("y", 0) > screen_height * NAV_BAR_ZONE and not is_nav_intent:
logger.error(f"❌ [Structural Guard] VLM selected element in nav bar zone for non-nav intent '{intent}': {match['semantic_string']}. REJECTING.")
logger.warning(f"🛡️ [Structural Guard] VLM selected element in nav bar zone for non-nav intent '{intent}': {match['semantic_string']}. REJECTING.")
return None
# ── Structural Guard 3: Already blacklisted ──
if self._is_blacklisted(intent, match["semantic_string"]):
logger.error(
f"❌ [Blacklist Guard] VLM selected previously-rejected element: "
logger.warning(
f"🛡️ [Blacklist Guard] VLM selected previously-rejected element: "
f"'{match['semantic_string']}'. REJECTING."
)
return None
@@ -1026,10 +1436,25 @@ class TelepathicEngine:
# 1. Structural Regex Check (Fastest and catches 'empty' or non-interactable modals)
if raw_xml_string:
# Look for any of the resource IDs in the raw XML string
pattern = "|".join(modal_res_ids).replace(".", "\\.")
if re.search(pattern, raw_xml_string):
return True
# We must be careful: some containers are always present but empty (e.g. bottom_sheet_camera_container)
# A modal is only "active" if it has actual content or is NOT a self-closing tag.
import re
for rid in modal_res_ids:
if "bottom_sheet_camera_container" in rid:
continue
# Search for the resource-id. If found, check if it's a self-closing node (/>)
# This is a heuristic: if we find the ID and it's immediately followed by "/>", it's empty.
# If it's followed by ">" then more tags, it likely has children.
pattern = rf'resource-id="{re.escape(rid)}"[^>]*>'
match = re.search(pattern, raw_xml_string)
if match:
# Check if the node is self-closing
if not match.group(0).endswith("/>"):
# It might have children. Verify if it actually contains nodes.
# For robustness, we'll verify if there is at least one child node before the next sibling.
logger.debug(f"🛡️ [Modal Guard] Detected potential active modal container: {rid}")
return True
# 2. Semantic Node Check (Iterative fallback)
for n in nodes:

2
GramAddict/core/unfollow_engine.py
View File

@@ -105,7 +105,7 @@ def _run_zero_latency_unfollow_loop(device, zero_engine, nav_graph, configs, ses
return "BOREDOM_CHANGE_FEED"
except Exception as e:
logger.error(f"⚠️ [FSD Anomaly Handler] Exception in Unfollow Loop: {e}")
logger.error(f"⚠️ [Anomaly Handler] Exception in Unfollow Loop: {e}")
_humanized_scroll_down(device)
failed_scrolls += 1
if failed_scrolls > 3:

68
GramAddict/core/utils.py
View File

@@ -81,3 +81,71 @@ def get_value(count, name, default=0):
return int(count)
except Exception:
return default
def is_ad(context_xml: str) -> bool:
"""
Returns True if the current XML context represents an Instagram Ad.
Scans for:
1. ad_cta_button
2. clips_single_image_ads_media_content
3. clips_browser_cta
4. universal_cta_description_layout
5. intent_aware_ad_pivot_container
This runs in <1ms per call and uses NO string or language matching.
"""
import xml.etree.ElementTree as ET
import re
AD_RESOURCE_IDS = {
"com.instagram.android:id/ad_cta_button",
"com.instagram.android:id/clips_single_image_ads_media_content",
"com.instagram.android:id/intent_aware_ad_pivot_container",
"com.instagram.android:id/ads_carousel_progress_bar",
"com.instagram.android:id/reel_ads_cta"
}
GENERIC_CTA_IDS = {
"com.instagram.android:id/clips_browser_cta",
"com.instagram.android:id/universal_cta_description_layout",
"com.instagram.android:id/universal_cta_text",
}
AD_CTA_WORDS = {
"install", "learn more", "shop now", "sign up", "mehr dazu", "jetzt einkaufen",
"installieren", "registrieren", "anmelden", "download", "herunterladen",
"get offer", "abonnieren", "subscribe", "whatsapp", "nachricht senden",
"send message", "jetzt anrufen", "call now", "contact us", "kontaktieren"
}
try:
clean_xml = re.sub(r'<\?xml.*?\?>', '', context_xml).strip()
root = ET.fromstring(clean_xml)
for node in root.iter("node"):
res_id = node.attrib.get("resource-id", "")
# 1. Direct Structural Match
if res_id in AD_RESOURCE_IDS:
return True
# 1.5 Generic CTAs require text checking to avoid flagging 'Use template' or 'Original audio'
if res_id in GENERIC_CTA_IDS:
text = node.attrib.get("text", "").strip().lower()
desc = node.attrib.get("content-desc", "").strip().lower()
combined = text + " " + desc
if any(w in combined for w in AD_CTA_WORDS):
return True
# 2. Secondary Label / Subtitle Checks (Aggressive)
res_id_lower = res_id.lower()
if "subtitle" in res_id_lower or "label" in res_id_lower or "ad_" in res_id_lower or "sponsor" in res_id_lower:
text = node.attrib.get("text", "").strip().lower()
content_desc = node.attrib.get("content-desc", "").strip().lower()
combined = text + " " + content_desc
if any(w in combined for w in {"ad", "sponsored", "gesponsert", "werbung", "anzeige"}):
# Exception: Ensure we don't block user bios containing these words unless it's a structural subtitle
if len(combined) < 20:
return True
except Exception:
pass
return False

2
GramAddict/core/zero_latency_engine.py
View File

@@ -6,7 +6,7 @@ logger = logging.getLogger(__name__)
class ZeroLatencyEngine:
"""
Project Singularity V7: The Zero-Latency Executor
The Zero-Latency Executor
This engine receives a pre-compiled heuristic (Regex/XPath) from the memory cache
and executes it against the local XML layout in under 5ms.
It is completely deterministic. No LLM calls happen here.