diff --git a/GramAddict/core/bot_flow.py b/GramAddict/core/bot_flow.py index 7e8f6bf..0a5f2a0 100644 --- a/GramAddict/core/bot_flow.py +++ b/GramAddict/core/bot_flow.py @@ -21,6 +21,7 @@ from GramAddict.core.dojo_engine import DojoEngine # Cognitive Stack from GramAddict.core.dopamine_engine import DopamineEngine +from GramAddict.core.goap import GoalExecutor from GramAddict.core.growth_brain import GrowthBrain from GramAddict.core.log import configure_logger from GramAddict.core.perception.feed_analysis import ( @@ -188,7 +189,6 @@ def start_bot(**kwargs): active_inference = ActiveInferenceEngine(username) # Core Autonomous Engines - from GramAddict.core.goap import GoalExecutor GoalExecutor.get_instance(device, username) zero_engine = ZeroLatencyEngine(device) @@ -349,9 +349,7 @@ def start_bot(**kwargs): logger.info( f"🧠 [Agent Orchestrator] Session started. Strategy: {growth_brain.strategy} | Persona: {getattr(configs.args, 'agent_persona', 'unknown')}" ) - - from GramAddict.core.goap import GoalExecutor - + # 1. Starten wir den GOAP Executor, um die UI-Struktur autonom zu erfassen goap = GoalExecutor.get_instance(device, username) # --- PHASE 0: Autonomous Profile Scanning --- @@ -447,10 +445,10 @@ def start_bot(**kwargs): has_scanned_own_profile = True while not dopamine.is_app_session_over(): - # 1. Ask the Growth Brain for a Desire - current_desire = growth_brain.get_current_desire(dopamine) + # 1. Ask the Growth Brain for a Strategic Objective + current_goal = growth_brain.get_current_goal(dopamine, getattr(configs.args, "goals", [])) - if current_desire == "ShiftContext": + if current_goal == "ShiftContext": logger.info("🧠 [Free Will] Boredom critical. Forcing app restart to clear context.") device.app_stop(device.app_id) random_sleep(2.0, 4.0) @@ -459,6 +457,30 @@ def start_bot(**kwargs): dopamine.boredom = max(0.0, dopamine.boredom * 0.2) continue + # 2. Execution: GOAP Plan & Execute (Autonomous Mode) + if getattr(configs.args, "goals", None): + logger.info(f"🤖 Autonomous Mode Active. Delegating to GoalExecutor for: {current_goal}") + + goal_executor = GoalExecutor( + device=device, + telepathic=telepathic, + memory=growth_brain.memory, + config=configs, + session_state=session_state, + ) + + result = goal_executor.achieve(current_goal) + + if result == "GOAL_ACHIEVED": + logger.info("✅ Goal achieved autonomously!") + else: + logger.warning(f"⚠️ Goal execution returned: {result}") + + continue # The GoalExecutor handles navigation internally + + # --- LEGACY PROCEDURAL FALLBACK (For config without goals) --- + current_desire = current_goal + # 2. Map Desire to Sub-Feed target_map = { "DiscoverNewContent": ["ExploreFeed", "ReelsFeed"], diff --git a/GramAddict/core/config.py b/GramAddict/core/config.py index faee532..d55fd8d 100644 --- a/GramAddict/core/config.py +++ b/GramAddict/core/config.py @@ -85,6 +85,9 @@ class Config: self.username = self.username[0] self.debug = self.config.get("debug", False) self.app_id = self.config.get("app_id", "com.instagram.android") + + # Autonomous Agent Goals + self.goals = self.config.get("goals", []) else: if "--debug" in self.args: self.debug = True diff --git a/GramAddict/core/dm_engine.py b/GramAddict/core/dm_engine.py index 97822e7..297b880 100644 --- a/GramAddict/core/dm_engine.py +++ b/GramAddict/core/dm_engine.py @@ -13,20 +13,20 @@ MAX_REPLIES_PER_INBOX_VISIT = 3 # Sentinel values that indicate missing message context. _EMPTY_CONTEXT_SENTINELS = frozenset({"no previous context", "", "none", "n/a"}) + # Structural resource-IDs that indicate a real "Send" button. -_SEND_BUTTON_MARKERS = frozenset({"send_button", "row_thread_composer_send"}) - - def _is_send_button(node: dict) -> bool: - """Structural verification: returns True only if the node is a real Send button.""" - attribs = node.get("original_attribs", {}) - rid = attribs.get("resource-id", "") - desc = attribs.get("content-desc", node.get("desc", "")).lower() - # Accept if resource-id contains a known send button marker - if any(marker in rid for marker in _SEND_BUTTON_MARKERS): + """Semantic verification: returns True if the node is identified as a Send button.""" + desc = (node.get("description") or node.get("desc", "")).lower() + text = (node.get("text") or "").lower() + rid = (node.get("id") or node.get("resource_id", "")).lower() + + # Accept if semantic markers indicate sending + if any(m in rid for m in ["send", "composer_button"]): return True - # Accept if content-desc is exactly "Send" (Instagram's canonical label) - if desc == "send": + if any(m in desc for m in ["send", "absenden"]): + return True + if text == "send" or text == "absenden": return True return False @@ -83,16 +83,14 @@ def _run_zero_latency_dm_loop(device, zero_engine, nav_graph, configs, session_s xml_dump = device.dump_hierarchy() # --- Zero Trust Structural Guard --- - # ----------------------------------- - # ZERO TRUST STRUCTURAL GUARD - # ----------------------------------- - # Validate we are actually in the Inbox or a Thread. - # Hallucinations can lead to "Privacy Settings" or "Profile" screens. - is_inbox = ( - 'resource-id="com.instagram.android:id/inbox_refreshable_thread_list_recyclerview"' in xml_dump - or 'resource-id="com.instagram.android:id/direct_inbox_action_bar"' in xml_dump - ) - is_thread = 'resource-id="com.instagram.android:id/direct_thread_header"' in xml_dump + from GramAddict.core.perception.screen_identity import ScreenIdentity, ScreenType + + identity_engine = ScreenIdentity(getattr(configs.args, "username", "")) + screen_info = identity_engine.identify(xml_dump) + + screen_type = screen_info["screen_type"] + is_inbox = screen_type == ScreenType.DM_INBOX + is_thread = screen_type == ScreenType.DM_THREAD if is_thread: logger.warning("⚠️ [Structural Guard] DM Engine trapped in an open thread. Escaping...") @@ -102,9 +100,11 @@ def _run_zero_latency_dm_loop(device, zero_engine, nav_graph, configs, session_s sleep(1.5) continue - if not is_inbox and not is_thread: + if not is_inbox: # We have drifted somewhere entirely alien (like Privacy Settings) - logger.error("🛑 [Structural Guard] Alien context detected. Not in Inbox. Triggering CONTEXT_LOST.") + logger.error( + f"🛑 [Structural Guard] Alien context detected ({screen_type}). Not in Inbox. Triggering CONTEXT_LOST." + ) return "CONTEXT_LOST" # ----------------------------------- diff --git a/GramAddict/core/growth_brain.py b/GramAddict/core/growth_brain.py index 8d5a241..1aa9493 100644 --- a/GramAddict/core/growth_brain.py +++ b/GramAddict/core/growth_brain.py @@ -94,6 +94,25 @@ class GrowthBrain: logger.info(f"🧠 [GrowthBrain] Strategy '{self.strategy}' dictated Desire: {selected_desire}") return selected_desire + def get_current_goal(self, dopamine_engine, available_goals: list[str]) -> str: + """ + Autonomously selects the next strategic goal. + If no goals are configured, falls back to legacy desires. + """ + import random + + if not available_goals: + # Legacy Desire Mapping (Fallback) + return self.get_current_desire(dopamine_engine) + + # Basic strategy: For now, randomly select a goal. + # Future: Weight by strategy, previous success, or time of day. + # Use DopamineEngine to influence 'boredom' switching if needed. + if dopamine_engine.boredom > 80: + return "ShiftContext" # High boredom triggers a context shift + + return random.choice(available_goals) + def get_circadian_pacing(self) -> float: """ Adjusts activity levels based on the current local time diff --git a/GramAddict/core/unfollow_engine.py b/GramAddict/core/unfollow_engine.py index b1330d6..98a1865 100644 --- a/GramAddict/core/unfollow_engine.py +++ b/GramAddict/core/unfollow_engine.py @@ -65,26 +65,15 @@ def _run_zero_latency_unfollow_loop( try: xml_dump = device.dump_hierarchy() - import re - - # Smart Unfollow Phase 1: Find user rows via structural UI markers, not LLM (too prone to hallucinate headers) + # Autonomously identify user rows via Semantic Extraction + telepathic = cognitive_stack.get("telepathic") nodes = [] - # Find all nodes with resource-id="com.instagram.android:id/follow_list_username" - for match in re.finditer( - r'resource-id="com\.instagram\.android:id/follow_list_username".*?bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"', - xml_dump, - ): - x1, y1, x2, y2 = map(int, match.groups()) - nodes.append({"x": (x1 + x2) // 2, "y": (y1 + y2) // 2, "bounds": True}) - - # Also try com.instagram.android:id/follow_list_container as fallback - if not nodes: - for match in re.finditer( - r'resource-id="com\.instagram\.android:id/follow_list_container".*?bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"', - xml_dump, - ): - x1, y1, x2, y2 = map(int, match.groups()) - nodes.append({"x": (x1 + x2) // 2, "y": (y1 + y2) // 2, "bounds": True}) + if telepathic: + nodes = telepathic._extract_semantic_nodes( + xml_dump, "List item containing a user profile image, username, and following/following button" + ) + else: + logger.warning("No telepathic engine found, skipping semantic extraction.") action_taken = False for node in nodes: diff --git a/tests/unit/test_autonomous_goals.py b/tests/unit/test_autonomous_goals.py new file mode 100644 index 0000000..87e2395 --- /dev/null +++ b/tests/unit/test_autonomous_goals.py @@ -0,0 +1,20 @@ +from unittest.mock import MagicMock + +from GramAddict.core.config import Config +from GramAddict.core.growth_brain import GrowthBrain + + +def test_autonomous_goals_config_parsing(): + """Test that goals can be parsed from args/config and passed to the brain.""" + mock_configs = MagicMock(spec=Config) + mock_configs.args = MagicMock() + mock_configs.args.goals = ["Discover new content", "Engage with community"] + + brain = GrowthBrain(username="test_user") + dopamine = MagicMock() + dopamine.boredom = 0 + + # This should return the first goal initially + goal = brain.get_current_goal(dopamine, mock_configs.args.goals) + + assert goal in mock_configs.args.goals diff --git a/tests/unit/test_bot_flow_autonomy.py b/tests/unit/test_bot_flow_autonomy.py new file mode 100644 index 0000000..117753f --- /dev/null +++ b/tests/unit/test_bot_flow_autonomy.py @@ -0,0 +1,29 @@ +from unittest.mock import patch + + +@patch("GramAddict.core.bot_flow.GoalExecutor") +def test_bot_flow_prioritizes_goals_over_desires(MockGoalExecutor): + """ + Test that when goals are present in config, the bot uses GoalExecutor + instead of the legacy desire mapping. + This should fail (RED) before we refactor bot_flow.py. + """ + mock_executor_instance = MockGoalExecutor.return_value + mock_executor_instance.achieve.return_value = "TaskCompleted" + + # We won't run the whole start_bot (it's massive), + # we'll just test the core orchestrator loop extraction if we can, + # or we can test the behavior by mocking the device and config. + + # Actually, a better way is to test that the goal string is passed to achieve. + # Since we can't easily mock the massive `start_bot`, we will test the + # conceptual behavior by just ensuring the code in bot_flow contains + # GoalExecutor.achieve logic. + + # Let's import the file and check for GoalExecutor usage + with open("GramAddict/core/bot_flow.py", "r") as f: + content = f.read() + + # This assertion will fail (RED) because GoalExecutor is not in the original bot_flow.py + assert "GoalExecutor" in content, "bot_flow.py does not use GoalExecutor for autonomous goals" + assert "goal_executor.achieve(current_goal)" in content, "bot_flow.py does not execute goals autonomously" diff --git a/tests/unit/test_dm_engine_autonomy.py b/tests/unit/test_dm_engine_autonomy.py new file mode 100644 index 0000000..19f25d0 --- /dev/null +++ b/tests/unit/test_dm_engine_autonomy.py @@ -0,0 +1,51 @@ +from unittest.mock import MagicMock + +from GramAddict.core.dm_engine import _run_zero_latency_dm_loop + + +def test_dm_engine_fails_on_structural_change_but_semantic_match(): + """ + Test that dm_engine fails when the hardcoded resource-ids are missing, + even though the screen semantically is the inbox. + This test should fail (RED) initially to prove the bug. + """ + mock_device = MagicMock() + mock_zero_engine = MagicMock() + mock_nav_graph = MagicMock() + mock_configs = MagicMock() + mock_session_state = MagicMock() + mock_cognitive_stack = {"telepathic": MagicMock(), "dopamine": MagicMock()} + + # Simulate dopamine limits + mock_cognitive_stack["dopamine"].is_app_session_over.return_value = False + mock_session_state.check_limit.return_value = False + + # The xml dump DOES NOT contain the hardcoded inbox ID: + # 'com.instagram.android:id/inbox_refreshable_thread_list_recyclerview' + # But it does contain semantic markers for an inbox. + mock_device.dump_hierarchy.return_value = """ + + + + + + + + + """ + + # We expect the engine to return 'CONTEXT_LOST' because of the hardcoded guard, + # but we want it to actually process the inbox. + result = _run_zero_latency_dm_loop( + mock_device, + mock_zero_engine, + mock_nav_graph, + mock_configs, + mock_session_state, + "MessageInbox", + mock_cognitive_stack, + ) + + # In the bugged version, it returns CONTEXT_LOST. + # We assert it should NOT return CONTEXT_LOST, making the test FAIL (RED) initially. + assert result != "CONTEXT_LOST", "DM Engine incorrectly aborted due to missing hardcoded resource-id" diff --git a/tests/unit/test_unfollow_engine_autonomy.py b/tests/unit/test_unfollow_engine_autonomy.py new file mode 100644 index 0000000..497986c --- /dev/null +++ b/tests/unit/test_unfollow_engine_autonomy.py @@ -0,0 +1,58 @@ +from unittest.mock import MagicMock + +from GramAddict.core.unfollow_engine import _run_zero_latency_unfollow_loop + + +def test_unfollow_engine_fails_on_structural_change_but_semantic_match(): + """ + Test that unfollow_engine fails when the hardcoded regex resource-id + com.instagram.android:id/follow_list_username is missing, even though + semantically the screen contains user rows. + """ + mock_device = MagicMock() + mock_zero_engine = MagicMock() + mock_nav_graph = MagicMock() + mock_configs = MagicMock() + mock_session_state = MagicMock() + + mock_telepathic = MagicMock() + + # Simulate finding user rows semantically + mock_telepathic._extract_semantic_nodes.return_value = [{"x": 100, "y": 200, "bounds": "[50,150][150,250]"}] + + mock_cognitive_stack = {"telepathic": mock_telepathic, "dopamine": MagicMock(), "resonance": MagicMock()} + + # Simulate dopamine limits so we only do 1 loop + mock_cognitive_stack["dopamine"].is_app_session_over.return_value = False + mock_session_state.check_limit.return_value = False + + # The xml dump DOES NOT contain the hardcoded username ID: + # 'com.instagram.android:id/follow_list_username' + mock_device.dump_hierarchy.return_value = """ + + + + + + + """ + + # In the bugged version, it won't find the rows and will scroll, + # eventually failing or returning "BOREDOM_CHANGE_FEED" without tapping. + # In the fixed version, it uses telepathic to find the node and clicks it. + + # We'll assert that it clicks the node. + _run_zero_latency_unfollow_loop( + mock_device, + mock_zero_engine, + mock_nav_graph, + mock_configs, + mock_session_state, + "FollowingList", + mock_cognitive_stack, + ) + + # We assert that _humanized_click (which calls device.click/swipe or similar eventually) is triggered. + # Actually, unfollow engine imports _humanized_click. + # If the user row is found, device.dump_hierarchy will be called multiple times (to check profile). + assert mock_device.dump_hierarchy.call_count > 1, "Unfollow Engine failed to find user rows due to regex dependency"