commit fa1d01527db8197c1beeb8b3795b4c1fde36be63 Author: Marc Mintel Date: Thu Apr 16 18:58:18 2026 +0200 init diff --git a/.coverage b/.coverage new file mode 100644 index 0000000..2315f28 Binary files /dev/null and b/.coverage differ diff --git a/.env b/.env new file mode 100644 index 0000000..6ebf0f3 --- /dev/null +++ b/.env @@ -0,0 +1 @@ +OPENROUTER_API_KEY=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 diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 0000000..c2c1317 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,32 @@ +--- +name: Bug Report +about: Report a bug encountered while operating GramAdict +labels: kind/bug + +--- + + + +**What happened**: + +**What you expected to happen**: + +**How to reproduce it (as minimally and precisely as possible)**: + +**Anything else we need to know?**: + +**Environment**: +- GramAddict version: +- Device Model/Emulator Type: +- Android Version: +- Instagram Version: +- Discord Ticket ID: *(if submitting crash log) + + +Relevant Logs: +- activate debug mode in confing.yml if you want to paste from the console, otherwise attach the log file from the logs folder + + + +


+### *Note: if you have a crash log, please do not attach the archive here as this is not a secure place to upload the sensitive data inside. Please open a ticket in [Discord](https://discord.com/invite/66zWWCDM7x) in #lobby and provide the ticket ID here. \ No newline at end of file diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 0000000..304ca5c --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,11 @@ +--- +name: Enhancement Request +about: Suggest an enhancement to the GramAddict project +labels: kind/feature + +--- + + +**What would you like to be added**: + +**Why is this needed**: diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 0000000..b085585 --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,36 @@ +# Description + +Please include a summary of the change and which issue is fixed. Please also include relevant motivation and context. List any dependencies that are required for this change. + +Fixes # (issue) + +## Type of change + +Please delete options that are not relevant. + +- [ ] Bug fix (non-breaking change which fixes an issue) +- [ ] New feature (non-breaking change which adds functionality) +- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected) +- [ ] This change requires a documentation update + +# How Has This Been Tested? + +Please describe the tests that you ran to verify your changes. Provide instructions so we can reproduce. Please also list any relevant details for your test configuration + +- [ ] Test A +- [ ] Test B + +**Test Configuration**: +* Device Model or Emulator: +* Android Verison: +* Instagram Version: + +# Checklist: + +- [ ] My code follows the style guidelines of this project +- [ ] I have performed a self-review of my own code +- [ ] I have commented my code, particularly in hard-to-understand areas +- [ ] I have made corresponding changes to the documentation +- [ ] My changes generate no new warnings +- [ ] I have tested my code in every way I can think of to prove my fix is effective or that my feature works +- [ ] Any dependent changes have been merged and published in downstream modules \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..85baa19 --- /dev/null +++ b/.gitignore @@ -0,0 +1,26 @@ +/venv* +/.venv +/build +/dump +/dist +/gramaddict.egg-info +/.idea +/.vscode +*.yml +!test_config.yml +*.json +*.xml +logs/ +*.pyc +__pycache__/ +.DS_Store +crashes +accounts +!config-examples/* +Pipfile +Pipfile.lock +*.pdf +*.mp4 +*.log* +*.ini +*.db diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md new file mode 100644 index 0000000..0091a99 --- /dev/null +++ b/ARCHITECTURE.md @@ -0,0 +1,32 @@ +# GramPilot Architecture + +Welcome to the internal workings of **GramPilot** (formerly GramAddict). This document outlines the radical shift from fixed-state deterministic scripting to our current **Vision-Language-Action (VLA)** architecture that powers our "Full Self-Driving" behavior. + +## Core Design Philosophy +We treat the Instagram Android App like a dynamic, partially-observable environment. Instead of maintaining thousands of fragile XPaths, the bot relies on a **Cognitive Stack** to infer intent, learn layouts dynamically, and mathematically avoid detection. + +--- + +## 1. The Telepathic Engine (3-Stage Resolution Cascade) +At the center of UI interactions is the `TelepathicEngine` which resolves semantic intent ("tap the like button") into precise screen coordinates via a strictly enforced performance cascade: +- **Stage 1.5: Deterministic Keyword Fast Path**. Over 90% of interactions are handled by a high-performance string matcher that costs 0 API tokens and executes in `<2ms`. +- **Stage 2: Vector Similarity Engine**. If keywords fail, an Ollama Semantic Embedding of the intent is generated and compared (Cosine Similarity) against cached UI vectors via Qdrant. Highly reliable for semantic synonyms. +- **Stage 3: Agentic Fallback**. The ultimate safety net. If visual confidence drops `<0.82`, it falls back to an OpenRouter LLM (e.g., `gemini-3.1-flash-lite-preview`) which parses the raw XML to structurally guarantee a hit without hallucination. + +## 2. Telepathic Memory & Autonomy +When Stage 3 successfully resolves an unknown interaction, the bot records the semantic signature into its positive memory (`telepathic_memory.json`). The next time the bot requires this action, it is instantly resolved via the local cache, guaranteeing that expensive LLM operations are only ever performed once per UI permutation. + +## 3. The Cognitive Stack + +### ⚖ī¸ Active Inference (Shadow Mode) +Found in `active_inference.py`. Based on the free-energy principle, the bot calculates "Surprise" (prediction errors). +- **Shadow Mode**: Before transitioning screens, the bot predicts the target UI. If it lands somewhere unexpected (a popup), it registers a prediction error, hits "Back", and averts a crash. + +### 🛡ī¸ Honeypot Radome +Found in `sensors/honeypot_radome.py`. +- Instagram deploys 1x1 pixel invisible traps to detect bots. The Radome parses the raw XML and topologically removes any nodes with `bounds="[0,0][0,0]"` *before* the bot's navigation engine evaluates it. + +### 💉 Dopamine Engine & Resonance Oracle +Instead of hardcoding limits like `max_likes = 50`, the bot stops interacting based on **simulated boredom**. +- The `ResonanceEngine` calculates the aesthetic score of content. +- The `DopamineEngine` uses this score to modulate pace. High resonance = engagement. Low resonance over multiple posts = early session termination (simulating human fatigue). diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..606a393 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,46 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project owner via email at marc@mintel.me. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [https://contributor-covenant.org/version/1/4][version] + +[homepage]: https://contributor-covenant.org +[version]: https://contributor-covenant.org/version/1/4/ diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..b47522e --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,54 @@ +# Contributing to GramPilot + +:+1::tada: First off, thanks for taking the time to contribute! :tada::+1: + +The following is a set of guidelines for contributing to **GramPilot**. GramPilot has evolved significantly from its original roots into an AI-driven, autonomous Vision-Language-Action (VLA) agent. + +Please follow these guidelines when submitting issues or pull requests. + +## Table Of Contents +- [How Can I Contribute?](#how-can-i-contribute) + - [Reporting Bugs](#reporting-bugs) + - [Suggesting Enhancements](#suggesting-enhancements) + - [Pull Requests](#pull-requests) +- [Development Paradigms](#development-paradigms) +- [Styleguides](#styleguides) + +--- + +## How Can I Contribute? + +### Reporting Bugs +Before filing an issue, please ensure the bug relates to GramPilot's core framework (e.g. Qdrant cache issues, VLA compilation timeouts, Active Inference crashes). Because GramPilot synthesizes its own UI Locators using VLMs, **do not open bugs about outdated Instagram UI Locators**. The bot heals itself using the Dojo Engine automatically. + +When filing an issue, please provide: +* The exact device or emulator and Instagram version. +* The error trace from `logs/marisaundmarc.log` containing the emojis (e.g. ⛩ī¸ Dojo Engine traces or ⚖ī¸ Active Inference states). +* Do not submit tickets without terminal output logs. + +### Suggesting Enhancements +We welcome architectural enhancements to the **Cognitive Stack**. +If you want to contribute, focus on logic that makes the bot more human or resilient: +* Adding new `sensors` (like the Honeypot Radome) to evade IG protections. +* Expanding `DopamineEngine` parameters for better pacing. +* Enhancing the VLM Prompts in `compiler_engine.py` for more robust heuristics. + +### Pull Requests +1. All changes must be tested locally. +2. If you add a new Cognitive Engine, it must be properly integrated into the `bot_flow.py` loop without relying on hardcoded delays `sleep(5)`. Use the thermodynamic delays derived from `ActiveInference`. +3. Do not re-introduce `config.yml` dependencies for deterministic actions (e.g. `max_likes`). We rely strictly on biological simulation. + +--- + +## Development Paradigms + +1. **NO HARDCODED XPATHS**: Do not PR changes that look like `device.xpath('//android.widget.Button...')`. Use the semantic intents via `_execute_transition`. +2. **NO HARDCODED PIXELS**: Never use hardcoded pixel coordinates for scrolling or swiping (e.g. `scroll(1000)`). Screens vary drastically in pixel density. Always use human-scale dimensions (cm) via `device.cm_to_pixels(4.5)` to ensure deterministic physical interaction scaling. +3. **ASYNCHRONOUS AUTO-LABELING**: Blocking network calls during UI automation cause timing errors. Ensure heavy computation (VLM generation) happens in background threads (e.g., `dojo_engine.py`). +4. **FAIL GRACEFULLY**: Instead of wrapping UI lookups in `try/except` and crashing, utilize the Shadow Mode (`predict_state`) so the agent can naturally press "Back" if confused. + +--- + +## Styleguides +All Python code must be formatted with `Black`. +Follow standard Git commit messages. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..a594ef0 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,23 @@ +FROM python:3.11-slim + +# Install ADB and system dependencies +RUN apt-get update && apt-get install -y \ + android-tools-adb \ + nano \ + curl \ + && rm -rf /var/lib/apt/lists/* + +WORKDIR /app + +# Copy requirements and install +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +# Copy source code +COPY . . + +# Environment setup +ENV PYTHONUNBUFFERED=1 + +# The default command will be overridden in docker-compose, but we can set a fallback +CMD ["python", "run.py", "--config", "test_config.yml"] diff --git a/GramAddict/__init__.py b/GramAddict/__init__.py new file mode 100644 index 0000000..b4c009e --- /dev/null +++ b/GramAddict/__init__.py @@ -0,0 +1,8 @@ +"""Human-like Instagram bot powered by UIAutomator2""" + +from GramAddict.core.version import __version__, __tested_ig_version__ + +from GramAddict.core.bot_flow import start_bot + +def run(**kwargs): + start_bot(**kwargs) diff --git a/GramAddict/__main__.py b/GramAddict/__main__.py new file mode 100644 index 0000000..cff8d27 --- /dev/null +++ b/GramAddict/__main__.py @@ -0,0 +1,162 @@ +from GramAddict.core.agentic_views import * +import argparse +from os import getcwd, path + +from GramAddict import __version__ +from GramAddict.core.bot_flow import start_bot +from GramAddict.core.download_from_github import download_from_github + + +def cmd_init(args): + if args.account_name is not None: + print(f"Script launched in {getcwd()}, files will be available there.") + for username in args.account_name: + if not path.exists("./run.py"): + print("Creating run.py ...") + download_from_github( + "https://github.com/GramAddict/bot/blob/master/run.py" + ) + if not path.exists(f"./accounts/{username}"): + print( + f"Creating 'accounts/{username}' folder with a config starting point inside. You have to edit these files according with https://docs.gramaddict.org/#/configuration" + ) + download_from_github( + "https://github.com/GramAddict/bot/tree/master/config-examples", + output_dir=f"accounts/{username}", + flatten=True, + ) + else: + print(f"'accounts/{username}' folder already exists, skip.") + continue + with open(f"./accounts/{username}/config.yml", "r+", encoding="utf-8") as f: + config = f.read() + f.seek(0) + config_fixed = config.replace("myusername", username) + f.write(config_fixed) + else: + print("You have to provide at last one account name..") + + +def cmd_run(args): + start_bot() + + +def cmd_dump(args): + import os + import shutil + import time + + import uiautomator2 as u2 + from colorama import Fore, Style + + if not args.no_kill: + os.popen("adb shell pkill atx-agent").close() + try: + d = u2.connect(args.device) + except RuntimeError as err: + raise SystemExit(err) + + def dump_hierarchy(device, path): + xml_dump = device.dump_hierarchy() + with open(path, "w", encoding="utf-8") as outfile: + outfile.write(xml_dump) + + def make_archive(name): + os.chdir("dump") + shutil.make_archive(base_name=f"screen_{name}", format="zip", root_dir="cur") + shutil.rmtree("cur") + + os.makedirs("dump/cur", exist_ok=True) + d.screenshot("dump/cur/screenshot.png") + dump_hierarchy(d, "dump/cur/hierarchy.xml") + archive_name = int(time.time()) + make_archive(archive_name) + print( + Fore.GREEN + + Style.BRIGHT + + "\nCurrent screen dump generated successfully! Please, send me this file:" + ) + print(Fore.BLUE + Style.BRIGHT + f"{os.getcwd()}\\screen_{archive_name}.zip") + + +_commands = [ + dict( + action=cmd_init, + command="init", + help="creates your account folder under accounts with files for configuration", + flags=[ + dict( + args=["account_name"], + nargs="+", + help="instagram account name to initialize", + ), + ], + ), + dict( + action=cmd_run, + command="run", + help="start the bot!", + flags=[ + dict(args=["--config"], nargs="?", help="provide the config.yml path"), + ], + ), + dict( + action=cmd_dump, + command="dump", + help="dump current screen", + flags=[ + dict( + args=["--device"], + nargs=None, + default=None, + help="provide the device name if more then one connected", + ), + dict( + args=["--no-kill"], + action="store_true", + help="don't kill the uia2 demon", + ), + ], + ), +] + + +def main() -> None: + parser = argparse.ArgumentParser( + prog="GramAddict", + description="free human-like Instagram bot", + ) + parser.add_argument( + "-v", "--version", action="version", version=f"{parser.prog} {__version__}" + ) + subparser = parser.add_subparsers(dest="subparser") + actions = {} + for c in _commands: + cmd_name = c["command"] + actions[cmd_name] = c["action"] + sp = subparser.add_parser( + cmd_name, + help=c.get("help"), + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + for f in c.get("flags", []): + args = f.get("args") + if not args: + args = ["-" * min(2, len(n)) + n for n in f["name"]] + kwargs = f.copy() + kwargs.pop("name", None) + kwargs.pop("args", None) + kwargs.pop("run", None) + sp.add_argument(*args, **kwargs) + + args = parser.parse_args() + + if args.subparser: + actions[args.subparser](args) + return + + parser.print_help() + + +if __name__ == "__main__": + main() diff --git a/GramAddict/core/__init__.py b/GramAddict/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/GramAddict/core/active_inference.py b/GramAddict/core/active_inference.py new file mode 100644 index 0000000..e366c14 --- /dev/null +++ b/GramAddict/core/active_inference.py @@ -0,0 +1,101 @@ +import logging +import time +import math +from datetime import datetime +from colorama import Fore + +logger = logging.getLogger(__name__) + +class ActiveInferenceEngine: + """ + Bayesian Active Inference Engine. + Calculates Free Energy (Surprise) based on prediction errors in the + Instagram environment. Steers the agent's 'Thermodynamic Policy'. + """ + def __init__(self, username): + self.username = username + self.free_energy = 0.0 + self.surprise_threshold = 0.75 + self.last_update = time.time() + self.policy = "STABLE" # STABLE, CAUTIOUS, DORMANT + self.expectation_history = [] + + def calculate_surprise(self, predicted_outcome: float, observed_outcome: float): + """ + Bayesian surprise calculation (simplified Kullback-Leibler divergence). + """ + # prediction error + error = abs(predicted_outcome - observed_outcome) + + # Free energy accumulation + self.free_energy = (self.free_energy * 0.7) + (error * 0.3) + + # Decay free energy over time (Thermodynamic relaxation) + now = time.time() + hours_passed = (now - self.last_update) / 3600.0 + decay = math.exp(-0.1 * hours_passed) + self.free_energy *= decay + self.last_update = now + + # Policy steering + if self.free_energy > 1.2: + self.policy = "DORMANT" + elif self.free_energy > self.surprise_threshold: + self.policy = "CAUTIOUS" + else: + self.policy = "STABLE" + + logger.info(f"⚖ī¸ [Active Inference] Surprise: {self.free_energy:.4f} | Policy: {self.policy}", extra={"color": f"{Fore.BLUE}"}) + return self.free_energy + + def predict_state(self, expected_signature: list): + """ + Registers an expectation about the future UI state before acting. + expected_signature: list of terms expected in the resulting XML. + """ + self.expectation_history.append(expected_signature) + logger.debug(f"⚖ī¸ [Shadow Mode] Predicting future state containing: {expected_signature}", extra={"color": f"{Fore.BLUE}"}) + + def evaluate_prediction(self, context_xml: str) -> bool: + """ + Evaluates the last prediction against reality. + Returns True if reality matches prediction, False otherwise (Prediction Error). + """ + if not self.expectation_history: + return True + + expected_signature = self.expectation_history.pop() + matched = any(sig.lower() in context_xml.lower() for sig in expected_signature) + + if matched: + self.calculate_surprise(1.0, 1.0) + return True + else: + logger.warning(f"⚖ī¸ [Shadow Mode] Prediction Error! Did not find {expected_signature} in resulting UI.", extra={"color": f"{Fore.RED}"}) + self.calculate_surprise(1.0, 0.0) + + # ── Dojo Data Engine Hook ── + # When prediction fails, explicitly submit the snapshot for shadow-compilation + try: + from GramAddict.core.dojo_engine import DojoEngine + # Note: get_instance() works without passing device as it was already initialized in bot_flow by this point. + dojo = DojoEngine.get_instance() + dojo.submit_snapshot( + heuristic_name=str(expected_signature), + context_xml=context_xml, + intent_prompt=f"Locate the missing elements or correct the heuristic predicting state: {expected_signature}" + ) + except Exception as e: + logger.error(f"Failed to offload snapshot to Dojo Engine: {e}") + + return False + + def get_sleep_modifier(self): + """ + Returns a multiplier for sleep durations based on surprise. + """ + if self.policy == "DORMANT": + return 5.0 + if self.policy == "CAUTIOUS": + return 2.0 + return 1.0 diff --git a/GramAddict/core/benchmark_guard.py b/GramAddict/core/benchmark_guard.py new file mode 100644 index 0000000..6e5ce84 --- /dev/null +++ b/GramAddict/core/benchmark_guard.py @@ -0,0 +1,76 @@ +import os +import json +import logging +from colorama import Fore, Style + +logger = logging.getLogger(__name__) + +BENCHMARKS_FILE = os.path.join(os.path.dirname(__file__), "llm_benchmarks.json") + +def check_model_benchmarks(configs): + """ + Checks the configured AI models against the local benchmark database. + Emits warnings if the user is running untested or underperforming models + that could lead to agent hallucinations or broken interactions. + """ + if not os.path.exists(BENCHMARKS_FILE): + return + + try: + with open(BENCHMARKS_FILE, "r") as f: + data = json.load(f) + benchmarks = data.get("models", {}) + except Exception as e: + logger.warning(f"Could not load LLM benchmarks: {e}") + return + + def _eval_model(model_name: str, context: str): + if not model_name: + return + + 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.", + extra={"color": f"{Style.BRIGHT}{Fore.RED}"} + ) + return + + scores = benchmarks[model_name] + + # Telepathic/Vision tasks require high structural strictness + if context == "Vision/Telepathic": + score = scores.get("telepathic_score", 0) + else: + score = scores.get("resonance_score", 0) + + if score < 50: + logger.error( + f"⛔ [Benchmark Guard] Model '{model_name}' (for {context}) achieved a CRITICAL FAILURE score " + f"of {score}/100. Autonomous safety is compromised. DO NOT RUN UNATTENDED.", + extra={"color": f"{Style.BRIGHT}{Fore.RED}"} + ) + elif score < 80: + logger.warning( + f"⚠ī¸ [Benchmark Guard] Model '{model_name}' (for {context}) achieved a SUB-STANDARD score " + f"of {score}/100. It may occasionally hallucinate UI elements or misinterpret semantics.", + extra={"color": f"{Style.BRIGHT}{Fore.YELLOW}"} + ) + else: + logger.info( + f"✅ [Benchmark Guard] Model '{model_name}' (for {context}) passes safety benchmarks ({score}/100).", + extra={"color": f"{Style.BRIGHT}{Fore.GREEN}"} + ) + + # Which models did the user configure? + telepathic_model = getattr(configs.args, "ai_telepathic_model", None) + text_model = getattr(configs.args, "ai_model", None) + condenser_model = getattr(configs.args, "ai_condenser_model", None) + + _eval_model(telepathic_model, "Vision/Telepathic") + + if text_model and text_model != telepathic_model: + _eval_model(text_model, "Dopamine/Resonance") + + if condenser_model and condenser_model != text_model and condenser_model != telepathic_model: + _eval_model(condenser_model, "Context Condensation") diff --git a/GramAddict/core/bot_flow.py b/GramAddict/core/bot_flow.py new file mode 100644 index 0000000..04c9585 --- /dev/null +++ b/GramAddict/core/bot_flow.py @@ -0,0 +1,1502 @@ +import logging + +import os +import re +import random +import time +from datetime import datetime +from time import sleep + +from colorama import Fore, Style + +from GramAddict.core.version import __version__, __tested_ig_version__ +from GramAddict.core.config import Config +from GramAddict.core.device_facade import create_device, get_device_info +from GramAddict.core.log import configure_logger +from GramAddict.core.persistent_list import PersistentList +from GramAddict.core.session_state import SessionState, SessionStateEncoder +from GramAddict.core.utils import ( + check_if_updated, + close_instagram, + get_instagram_version, + open_instagram, + random_sleep, + set_time_delta, + wait_for_next_session, +) + +# Cognitive Stack V8 +from GramAddict.core.dopamine_engine import DopamineEngine +from GramAddict.core.resonance_engine import ResonanceEngine +from GramAddict.core.active_inference import ActiveInferenceEngine +from GramAddict.core.growth_brain import GrowthBrain +from GramAddict.core.swarm_protocol import SwarmProtocol +from GramAddict.core.darwin_engine import DarwinEngine +from GramAddict.core.q_nav_graph import QNavGraph +from GramAddict.core.zero_latency_engine import ZeroLatencyEngine +from GramAddict.core.unfollow_engine import _run_zero_latency_unfollow_loop +from GramAddict.core.dm_engine import _run_zero_latency_dm_loop +from GramAddict.core.telepathic_engine import TelepathicEngine +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 + +logger = logging.getLogger(__name__) + +def start_bot(**kwargs): + configs = Config(first_run=True, **kwargs) + configure_logger(configs.debug, configs.username) + check_if_updated() + + from GramAddict.core.benchmark_guard import check_model_benchmarks + check_model_benchmarks(configs) + + from GramAddict.core.llm_provider import log_openrouter_burn + log_openrouter_burn() + + # Check for direct execution modes that bypass normal bot state + configs.parse_args() + + if getattr(configs.args, "capture_e2e_dumps", False): + device = create_device(configs.device_id, configs.app_id, configs.args) + from GramAddict.core.dump_capturer import capture_all + capture_all(device) + return + + sessions = PersistentList("sessions", SessionStateEncoder) + device = create_device(configs.device_id, configs.app_id, configs.args) + + + + # Initialize Cognitive Stack with proper dependencies + username = configs.username or "singular_user" + + # Parse persona interests from config (comma-separated string → list) + persona_raw = getattr(configs.args, "ai_target_audience", getattr(configs.args, "persona_interests", "")) + persona_interests = [p.strip() for p in persona_raw.split(",") if p.strip()] if persona_raw else [] + + dopamine = DopamineEngine() + crm_db = ParasocialCRMDB() + resonance_oracle = ResonanceEngine(username, persona_interests=persona_interests, crm=crm_db) + active_inference = ActiveInferenceEngine(username) + + # Singularity V8: Core Autonomous Engines + zero_engine = ZeroLatencyEngine(device) + nav_graph = QNavGraph(device) + growth_brain = GrowthBrain(username, persona_interests=persona_interests) + + info = device.get_info() + radome = HoneypotRadome(info.get("displayWidth", 1080), info.get("displayHeight", 2400)) + + swarm = SwarmProtocol(username) + darwin = DarwinEngine(username) + + from GramAddict.core.telepathic_engine import TelepathicEngine + telepathic = TelepathicEngine() + + cognitive_stack = { + "active_inference": active_inference, + "dopamine": dopamine, + "swarm": swarm, + "resonance": resonance_oracle, + "growth_brain": growth_brain, + "radome": radome, + "nav_graph": nav_graph, + "zero_engine": zero_engine, + "telepathic": telepathic, + "darwin": darwin, + "crm": crm_db, + } + + + is_first_session = True + + dojo = DojoEngine.get_instance(device) + dojo.start() + cognitive_stack["dojo"] = dojo + + try: + while True: + set_time_delta(configs.args) + inside_working_hours, time_left = SessionState.inside_working_hours( + configs.args.working_hours, configs.args.time_delta_session + ) + if not inside_working_hours: + wait_for_next_session(time_left, None, sessions, device) + + get_device_info(device) + session_state = SessionState(configs) + session_state.set_limits_session() + sessions.append(session_state) + device.wake_up() + + logger.info( + "-------- START SINGULARITY SESSION: " + + str(session_state.startTime.strftime("%H:%M:%S - %Y/%m/%d")) + + " --------", + extra={"color": f"{Style.BRIGHT}{Fore.YELLOW}"}, + ) + + if open_instagram(device, force_restart=False): + if is_first_session: + # 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" + is_first_session = False + try: + running_ig_version = get_instagram_version(device) + logger.debug(f"Instagram version: {running_ig_version}") + except Exception as e: + logger.error(f"Error retrieving the IG version: {e}") + + # V8 Free Will Execution Pipeline + 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, "total_unfollows_limit", 0): + 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) + + logger.info(f"🧠 [Free Will] Session started. Decided to visit {current_target} first (out of {len(available_targets)} options).") + + while not dopamine.is_app_session_over(): + 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", zero_engine) + # 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", zero_engine) + _wait_for_post_loaded(device, timeout=5) + + if current_target == "StoriesFeed": + result = _run_zero_latency_stories_loop(device, configs, session_state, cognitive_stack) + elif current_target == "FollowingList": + result = _run_zero_latency_unfollow_loop(device, zero_engine, nav_graph, configs, session_state, current_target, cognitive_stack) + elif current_target == "MessageInbox": + result = _run_zero_latency_dm_loop(device, zero_engine, nav_graph, configs, session_state, current_target, cognitive_stack) + elif current_target == "SearchFeed": + result = _run_zero_latency_search_loop(device, zero_engine, nav_graph, configs, session_state, current_target, cognitive_stack) + else: + is_reels = (current_target == "ReelsFeed") + result = _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session_state, current_target, cognitive_stack, is_reels=is_reels) + + # Evaluate outcome from loop + if result == "BOREDOM_CHANGE_FEED": + available_targets_copy = [t for t in available_targets if t != current_target] + current_target = secrets.choice(available_targets_copy) if available_targets_copy else current_target + logger.info(f"🧠 [Free Will] Spontaneous desire changed. Switching to {current_target}.") + elif result == "CONTEXT_LOST": + logger.warning(f"⚠ī¸ Context was lost in {current_target}. Forcing re-navigation to recover.") + nav_graph.current_state = "UNKNOWN" + continue + else: + break # Session over or unhandled state + else: + logger.error(f"Aborting target {current_target} due to navigation failure.") + break + + logger.info(f"Session complete. Boredom: {dopamine.boredom:.1f}%. Sleeping before next iteration...") + close_instagram(device) + random_sleep(30, 60) + + except KeyboardInterrupt: + logger.info("🛑 Caught KeyboardInterrupt! Creating diagnostic dump of current UI state before exiting...") + dump_ui_state(device, "manual_interrupt") + raise + finally: + if 'dojo' in locals() and dojo.is_running: + dojo.stop() + +FEED_MARKERS = [ + "row_feed_photo_profile_name", + "row_feed_profile_header", + "row_feed_photo_imageview", + "clips_media_component", +] + + + + +def _wait_for_post_loaded(device, timeout=5): + """Polls the UI hierarchy until feed markers appear, confirming a post is on screen.""" + start = time.time() + while time.time() - start < timeout: + try: + xml = device.deviceV2.dump_hierarchy() + if any(marker in xml for marker in FEED_MARKERS): + logger.debug("📱 Post loaded successfully.") + return True + except Exception: + pass + sleep(0.5) + logger.warning("⚠ī¸ Post did not load within timeout. Proceeding anyway.") + dump_ui_state(device, "post_load_timeout", {"timeout_sec": timeout}) + return False + +def _humanized_scroll(device, is_skip=False): + """ + 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. + """ + import random + info = device.get_info() + w, h = info.get("displayWidth", 1080), info.get("displayHeight", 2400) + + # 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)) + + # Thumb starts relatively low on the screen + start_y = int(h * random.uniform(0.70, 0.85)) + + 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 + else: + # Playful, organic human scrolling + play_choice = random.random() + + if play_choice > 0.85: + # "Go back" / Scroll UP (15% chance) + # 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...") + + elif play_choice > 0.60: + # "Reading Jitter" / Playing around (25% chance) + # Very short, slow movements up and down + distance = int(h * random.uniform(0.05, 0.15)) + duration = random.uniform(0.30, 0.60) + # 50% chance to jitter up or down + if random.random() > 0.5: + end_y = start_y - distance + else: + start_y = int(h * random.uniform(0.30, 0.50)) + end_y = start_y + distance + logger.info("đŸĒ€ [Playful Scroll] Micro-jitter / playing around...") + + 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 + 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) + 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). + # UIAutomator2's internal swipe often kills momentum by calculating a zero velocity touch-up. + device.deviceV2.shell(f"input swipe {int(start_x)} {int(start_y)} {int(end_x)} {int(end_y)} {duration_ms}") + +def _humanized_click(device, x, y, double=False, sleep_mod=1.0): + import random + from time import sleep + + def single_sloppy_tap(): + # Jitter radius: 3 to 12 pixels based on screen resolution approximation + noise_x = random.randint(-10, 10) + noise_y = random.randint(-10, 10) + start_x, start_y = x + noise_x, y + noise_y + + # Micro-drift to simulate thumb rolling on the glass during tap (1-4 pixels) + end_x = start_x + random.randint(-4, 4) + end_y = start_y + random.randint(-4, 4) + + # Duration for a human tap + duration = random.randint(40, 90) + device.deviceV2.shell(f"input swipe {int(start_x)} {int(start_y)} {int(end_x)} {int(end_y)} {duration}") + + if double: + # Double tap (Fast, slightly overlapping jitter) + single_sloppy_tap() + sleep(random.uniform(0.08, 0.15)) + single_sloppy_tap() + else: + single_sloppy_tap() + +def _humanized_horizontal_swipe(device, start_x, end_x, y, duration_ms): + import random + # Thumb arc simulation: curve Y axis as we drag X + noise_start_y = random.randint(-15, 15) + + # Typically going right to left thumb drops slightly down towards palm center + y_drift = random.randint(30, 90) if start_x > end_x else random.randint(-90, -30) + + # Speed variance + jitter_dist_x = random.randint(-20, 20) + + actual_start_x = int(start_x) + actual_end_x = int(end_x) + jitter_dist_x + actual_start_y = int(y) + noise_start_y + actual_end_y = int(y) + noise_start_y + y_drift + + # Introduce +- 30% timing wobble + actual_duration = int(duration_ms * random.uniform(0.7, 1.3)) + + device.deviceV2.shell(f"input swipe {actual_start_x} {actual_start_y} {actual_end_x} {actual_end_y} {actual_duration}") + + +def has_carousel_in_view(xml_dump: str) -> bool: + """ + Checks if a carousel is present on screen based on standard Android UI identifiers. + Handles 'carousel_page_indicator', 'carousel_media_group', and 'carousel_viewpager'. + """ + indicators = [ + "com.instagram.android:id/carousel_page_indicator", + "com.instagram.android:id/carousel_media_group", + "com.instagram.android:id/carousel_viewpager" + ] + return any(ind in xml_dump for ind in indicators) + +def _interact_with_carousel(device, configs, sleep_mod, logger): + import random + from time import sleep + from colorama import Fore + carousel_pct = float(getattr(configs.args, "carousel_percentage", 0)) / 100.0 + if random.random() < carousel_pct: + carousel_count_str = getattr(configs.args, "carousel_count", "1-2") + try: + min_c, max_c = map(int, carousel_count_str.split('-')) + count = random.randint(min_c, max_c) + except: + count = 1 + logger.info(f"📸 [Carousel] Interacting with carousel. Swiping {count} times...", extra={"color": f"{Fore.CYAN}"}) + info = device.get_info() + w, h = info.get("displayWidth", 1080), info.get("displayHeight", 2400) + + for i in range(count): + sleep(random.uniform(1.5, 3.5) * sleep_mod) + # Horizontal swipe inside the post bounds (approx middle): Right to left + _humanized_horizontal_swipe(device, start_x=w*0.8, end_x=w*0.2, y=h*0.5, duration_ms=250) + sleep(random.uniform(1.0, 2.0) * sleep_mod) + +def _interact_with_profile(device, configs, username, session_state, sleep_mod, logger): + print("HELLO IM NOT MOCKED!") + """Deep interaction on a profile: Stories, Grid Likes, Follows""" + import random + + if hasattr(session_state, 'my_username') and username == session_state.my_username: + logger.info(f"🤝 [Deep Interaction] Skipping own profile @{username} to prevent self-interactions.") + return + + info = device.get_info() + w, h = info.get("displayWidth", 1080), info.get("displayHeight", 2400) + + # Profile Scraping (Phase 11: Data Extraction) + if getattr(configs.args, "scrape_profiles", False): + try: + logger.info(f"📊 [Scraping] Extracting metadata for @{username}...", extra={"color": f"{Fore.CYAN}"}) + xml_dump = device.deviceV2.dump_hierarchy() + telepathic = TelepathicEngine.get_instance() + crm = cognitive_stack.get("crm") if 'cognitive_stack' in locals() else None + + # Simple heuristic for extraction (followers/following) + f_node = telepathic.find_best_node(xml_dump, "Followers count text or number", device=device) + fg_node = telepathic.find_best_node(xml_dump, "Following count text or number", device=device) + bio_node = telepathic.find_best_node(xml_dump, "User biography or description text", device=device) + + scraped_data = { + "username": username, + "followers": f_node.get("text") if f_node else "unknown", + "following": fg_node.get("text") if fg_node else "unknown", + "bio": bio_node.get("text") if bio_node else "No bio" + } + + logger.info(f"✅ [Scraping] Data acquired: {scraped_data['followers']} followers, {scraped_data['following']} following.") + session_state.add_interaction(source=username, succeed=False, followed=False, scraped=True) + + if crm: + crm.log_interaction(username, "scrape", metadata=scraped_data) + except Exception as e: + logger.warning(f"⚠ī¸ [Scraping] Error during profiling: {e}") + + # Random Story Viewing + stories_pct = float(getattr(configs.args, "stories_percentage", 0)) / 100.0 + if random.random() < stories_pct: + stories_count_str = getattr(configs.args, "stories_count", "1-2") + try: + min_st, max_st = map(int, stories_count_str.split('-')) + count = random.randint(min_st, max_st) + except: + count = 1 + + telepathic = TelepathicEngine.get_instance() + xml_dump = device.deviceV2.dump_hierarchy() + story_ring_node = telepathic.find_best_node(xml_dump, "Profile picture avatar story ring", device=device) + + if story_ring_node and not story_ring_node.get("skip"): + _humanized_click(device, story_ring_node["x"], story_ring_node["y"], sleep_mod=sleep_mod) + sleep(random.uniform(2.5, 4.0) * sleep_mod) + + # ── Post-Click Verification: Did the story viewer actually open? ── + post_xml = device.deviceV2.dump_hierarchy() + story_indicators = ["reel_viewer", "story_viewer", "reel_pager", "camera_settings", "story_media"] + story_opened = any(ind in post_xml for ind in story_indicators) + + if not story_opened: + # Fallback: if profile elements (header/bio) disappeared, something opened + story_opened = "profile_header" in xml_dump and "profile_header" not in post_xml + + if story_opened: + telepathic.confirm_click("Profile picture avatar story ring") + logger.info(f"📸 [Story] Viewing @{username}'s story ({count} times)...") + for i in range(count): + sleep(random.uniform(2.0, 5.0) * sleep_mod) + if i < count - 1: + _humanized_click(device, int(w * 0.9), int(h * 0.5), sleep_mod=sleep_mod) + device.deviceV2.press("back") + sleep(random.uniform(1.0, 2.0) * sleep_mod) + else: + telepathic.reject_click("Profile picture avatar story ring") + logger.warning(f"⚠ī¸ [Story] Click did NOT open story viewer for @{username}. Learning from failure.") + device.deviceV2.press("back") + sleep(random.uniform(0.5, 1.0)) + + # Random Follow + follow_pct = float(getattr(configs.args, "follow_percentage", 0)) / 100.0 + from GramAddict.core.session_state import SessionState + if session_state.check_limit(SessionState.Limit.FOLLOWS): + follow_pct = 0.0 + + if random.random() < follow_pct: + xml_dump = device.deviceV2.dump_hierarchy() + telepathic = TelepathicEngine.get_instance() + follow_btn = telepathic.find_best_node(xml_dump, "tap follow button on profile", device=device) + if follow_btn and not follow_btn.get("skip"): + _humanized_click(device, follow_btn["x"], follow_btn["y"], sleep_mod=sleep_mod) + sleep(random.uniform(2.0, 4.0) * sleep_mod) + + # ── Post-Click Verification: Did follow state change? ── + post_xml = device.deviceV2.dump_hierarchy().lower() + # If the button now says "Following", "Abonniert", or "Requested" + if any(word in post_xml for word in ["following", "abonniert", "requested"]): + telepathic.confirm_click("tap follow button on profile") + logger.info(f"🤝 [Deep Interaction] Followed @{username} ✓") + session_state.totalFollowed[username] = 1 + else: + telepathic.reject_click("tap follow button on profile") + logger.warning(f"⚠ī¸ [Follow] Click did not change follow state for @{username}. Learning from failure.") + + # Grid Likes + likes_pct = float(getattr(configs.args, "likes_percentage", 0)) / 100.0 + if session_state.check_limit(SessionState.Limit.LIKES): + likes_pct = 0.0 + + if random.random() < likes_pct: + likes_count_str = getattr(configs.args, "likes_count", "1-2") + try: + min_l, max_l = map(int, likes_count_str.split('-')) + count = random.randint(min_l, max_l) + except: + count = 1 + + xml_dump = device.deviceV2.dump_hierarchy() + telepathic = TelepathicEngine.get_instance() + first_post = telepathic.find_best_node(xml_dump, "first image post in profile grid", device=device) + if first_post and not first_post.get("skip"): + _humanized_click(device, first_post["x"], first_post["y"], sleep_mod=sleep_mod) + sleep(random.uniform(2.5, 4.5) * sleep_mod) + + # ── Post-Click Verification: Did a post open? ── + post_xml = device.deviceV2.dump_hierarchy() + # Post view has like buttons or media groups + post_opened = any(ind in post_xml for ind in ["button_like", "button_comment", "media_group"]) + if not post_opened: + # If grid is gone, something opened + post_opened = "profile_grid" in xml_dump and "profile_grid" not in post_xml + + if post_opened: + telepathic.confirm_click("first image post in profile grid") + logger.info(f"❤ī¸ [Deep Interaction] Opening grid to drop {count} likes on @{username}...") + + for i in range(count): + _humanized_click(device, w // 2, h // 2, double=True, sleep_mod=sleep_mod) + session_state.totalLikes += 1 + logger.debug(f"Liked grid post {i+1}/{count}") + sleep(random.uniform(1.0, 2.0) * sleep_mod) + start_scroll_y, end_scroll_y = int(h * 0.7) + random.randint(-20, 20), int(h * 0.2) + random.randint(-40, 40) + scroll_x = w // 2 + random.randint(-30, 30) + device.deviceV2.shell(f"input swipe {scroll_x} {start_scroll_y} {scroll_x + random.randint(-15,15)} {end_scroll_y} {random.randint(250, 400)}") + sleep(random.uniform(1.5, 3.0) * sleep_mod) + + device.deviceV2.press("back") + sleep(random.uniform(1.0, 2.0) * sleep_mod) + else: + telepathic.reject_click("first image post in profile grid") + logger.warning(f"⚠ī¸ [Grid] Click did not open post for @{username}. Learning from failure.") + device.deviceV2.press("back") + sleep(random.uniform(0.5, 1.0)) + # Let the native UI momentum scroll finish just like a human watching the feed + sleep(random.uniform(1.2, 2.0)) + + # Hesitation mistake (humans sometimes pause randomly) + if random.randint(1, 100) <= 5: + sleep(random.uniform(1.5, 3.5)) + +def _align_active_post(device): + """ + Programmatic snapping correction. Finds the nearest post header and perfectly + snaps it to the top margin. Fixes inverted scroll mapping that pushed content away. + Loops to ensure absolute alignment if stuck deeply between posts. + """ + import xml.etree.ElementTree as ET + import re + + aligned = False + attempts = 0 + max_attempts = 3 + + while not aligned and attempts < max_attempts: + attempts += 1 + try: + xml = device.deviceV2.dump_hierarchy() + clean_xml = re.sub(r'<\?xml.*?\?>', '', xml).strip() + root = ET.fromstring(clean_xml) + + target_node = None + for node in root.iter('node'): + if "row_feed_profile_header" in node.attrib.get("resource-id", ""): + target_node = node + break + + if target_node is not None: + bounds = target_node.attrib.get('bounds', '') + m = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds) + if m: + l, t, r, b = map(int, m.groups()) + header_y = (t + b) // 2 + + # Instagram's optimal top margin for a snapped post is ~200-280px + target_y = 250 + diff = header_y - target_y + + # If target is off-center (> 100px), execute a precise correction swipe without momentum + if abs(diff) > 100: + info = device.get_info() + w, h = info.get("displayWidth", 1080), info.get("displayHeight", 2400) + cx = w // 2 + + max_safe_swipe = int(h * 0.4) + + if diff > 0: + # Content is too LOW. Move it UP. Finger moves UP (bottom to top). + dist = min(diff, max_safe_swipe) + start_y = int(h * 0.7) + end_y = start_y - dist + else: + # Content is too HIGH. Move it DOWN. Finger moves DOWN (top to bottom). + dist = min(abs(diff), max_safe_swipe) + start_y = int(h * 0.3) + end_y = start_y + dist + + # Duration 1.0s equals a precise mechanical drag with ZERO momentum (no flinging) + device.deviceV2.swipe(cx, start_y, cx, end_y, duration=1.0) + sleep(1.0) # Wait for UI to settle + logger.debug(f"📐 [Alignment] Snapping attempt {attempts}: Shifted {diff}px.") + else: + aligned = True + else: + break # No header found, cannot align + except Exception as e: + logger.debug(f"📐 [Alignment] Snapping correction failed: {e}") + break + + if aligned and attempts > 1: + logger.debug(f"📐 [Alignment] Snapped post cleanly into view after {attempts} attempts.") + 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/clips_browser_cta", + "com.instagram.android:id/universal_cta_description_layout", + "com.instagram.android:id/universal_cta_text", + "com.instagram.android:id/intent_aware_ad_pivot_container" + } + + 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 + + # 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. + This is the BOT'S EYES — what it actually "sees" about each post. + + Returns: + {'username': str, 'description': str, 'caption': str} + """ + import xml.etree.ElementTree as ET + + result = {"username": "", "description": "", "caption": ""} + + try: + root = ET.fromstring(context_xml) + for node in root.iter("node"): + res_id = node.attrib.get("resource-id", "") + text = node.attrib.get("text", "").strip() + desc = node.attrib.get("content-desc", "").strip() + + # Username from the post header (ignore commenters/composers) + if "row_feed_photo_profile_name" in res_id and text: + if "comment" not in res_id and "composer" not in res_id: + # Prioritize the FIRST valid username found (usually the header) + if not result["username"]: + result["username"] = text + + # Rich description from the main media (Instagram puts caption + metadata here) + if res_id in ( + "com.instagram.android:id/carousel_video_media_group", + "com.instagram.android:id/row_feed_photo_imageview", + "com.instagram.android:id/clips_media_component", + ) and desc and len(desc) > 10: + result["description"] = desc + + # Header description ("X posted a photo/video Y") + if "row_feed_profile_header" in res_id and desc: + if not result["description"]: + result["description"] = desc + + # Visible caption text (if the caption is expanded) + if not res_id and text and len(text) > 20 and result["username"] and result["username"] in text: + result["caption"] = text + + except Exception: + pass + + return result + +def _run_zero_latency_stories_loop(device, configs, session_state, cognitive_stack): + """ + Project Singularity V8: Top-Level Stories Bingewatching Loop + Mimics a user opening the story tray and endlessly tapping through stories. + Relies on DopamineEngine for early exit (boredom). + """ + import random + from time import sleep + from colorama import Fore + from GramAddict.core.utils import random_sleep + from GramAddict.core.dopamine_engine import DopamineEngine + logger.info("đŸŽŦ [StoriesFeed] Starting native story binging loop...", extra={"color": f"{Fore.CYAN}"}) + + dopamine = cognitive_stack.get("dopamine") + info = device.get_info() + w, h = info.get("displayWidth", 1080), info.get("displayHeight", 2400) + sleep_mod = float(getattr(configs.args, "speed_multiplier", 1.0)) + + stories_arg_str = getattr(configs.args, "stories", "999") or "999" + try: + min_st, max_st = map(int, stories_arg_str.split('-')) + limit = random.randint(min_st, max_st) + except: + try: + limit = int(stories_arg_str) + except ValueError: + limit = 999 + + iteration = 0 + + while not dopamine.is_app_session_over() and iteration < limit: + iteration += 1 + + # Check for boredom + if dopamine.wants_to_change_feed(): + logger.info("🧠 [Dopamine] Bored. Escaping StoriesFeed to seek new stimuli.") + device.deviceV2.press("back") # Attempt to back out to feed + sleep(random.uniform(1.0, 2.0) * sleep_mod) + return "BOREDOM_CHANGE_FEED" + + xml_dump = device.deviceV2.dump_hierarchy() + if not xml_dump: + logger.warning("Failed to dump UI hierarchy in StoriesFeed.") + return "CONTEXT_LOST" + + # Tap right to go next + _humanized_click(device, int(w * 0.85), int(h * 0.5), sleep_mod=sleep_mod) + sleep(random.uniform(2.0, 5.0) * sleep_mod) + + logger.info("đŸŽŦ [StoriesFeed] Session completed naturally.") + device.deviceV2.press("back") + return "SESSION_OVER" + + +def _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session_state, job_target, cognitive_stack, is_reels=False): + """ + The ultra-fast autonomous Free Will loop. + + ALL engines are wired in a closed feedback loop: + - ResonanceEngine evaluates content → drives Dopamine + Darwin + Interactions + - ActiveInference predicts UI state → modulates caution level + - GrowthBrain applies circadian pacing → modulates ALL sleep durations + - Darwin is the SOLE dwell controller → no duplicate sleep calls + - SwarmProtocol emits pheromones after successful interactions + """ + logger.info(f"🔄 Entering Zero-Latency Interaction Pool. Feed: {job_target}") + + dopamine = cognitive_stack.get("dopamine") + darwin = cognitive_stack.get("darwin") + resonance = cognitive_stack.get("resonance") + ai = cognitive_stack.get("active_inference") + growth = cognitive_stack.get("growth_brain") + swarm = cognitive_stack.get("swarm") + + # Track interaction outcomes for end-of-session learning + session_outcomes = [] + consecutive_marker_misses = 0 + consecutive_ads = 0 + + from GramAddict.core.session_state import SessionState + + iteration = 0 + while not dopamine.is_app_session_over(): + limit_tuple = session_state.check_limit(SessionState.Limit.ALL) + if any(limit_tuple): + logger.info("🚧 [Limits] Total interactions limit reached. Ending session.") + break + + iteration += 1 + if dopamine.wants_to_change_feed(): + # 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: + 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) + + # 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() + 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") + + sleep(random.uniform(1.0, 2.0)) + 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 + sleep_mod = circadian * caution_mod # Combined sleep multiplier + + if dopamine.wants_to_doomscroll(): + logger.info("🏃 [Drive] Doomscrolling engaged. Fast-skipping feed.", extra={"color": f"{Fore.CYAN}"}) + _humanized_scroll(device, is_skip=True) + sleep(random.uniform(0.1, 0.4) * sleep_mod) + continue + + # ── Boredom Engine (Notifications / DMs) ── + if random.random() < 0.03: + logger.info("đŸĨą [Boredom] Checking something else (Notifications/DMs) for a second...", extra={"color": f"{Fore.MAGENTA}"}) + # Activity tab usually has content-desc "Activity" or resource-id "newsfeed_tab" + newsfeed_tab = device.deviceV2(resourceId="com.instagram.android:id/newsfeed_tab") + direct_tab = device.deviceV2(descriptionContains="Messaging") + # Fallbacks: + if not direct_tab.exists: direct_tab = device.deviceV2(descriptionContains="Message") + + if random.random() < 0.5 and newsfeed_tab.exists: + newsfeed_tab.click() + elif direct_tab.exists: + direct_tab.click() + + sleep(random.uniform(3.0, 6.0) * sleep_mod) + + # Return to feed natively + feed_tab = device.deviceV2(resourceId="com.instagram.android:id/feed_tab") + if feed_tab.exists: + feed_tab.click() + else: + device.deviceV2.press("back") + sleep(random.uniform(1.0, 2.5) * sleep_mod) + + context_xml = device.deviceV2.dump_hierarchy() + if cognitive_stack.get("radome"): + context_xml = cognitive_stack.get("radome").sanitize_xml(context_xml) + + # ── Zero-Node Recovery (Graceful Degradation) ── + telepathic = TelepathicEngine.get_instance() + 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...", + extra={"color": f"{Fore.YELLOW}"} + ) + device.deviceV2.press("back") + sleep(0.5) + _humanized_scroll(device) + sleep(random.uniform(1.0, 2.0) * sleep_mod) + continue + + # ── Context Validation (Is the bot ACTUALLY on a post?) ── + has_feed_markers = any(marker in context_xml for marker in FEED_MARKERS) + + # ── Z-Depth Obstacle Detection ── + # Instagram often renders feed markers in the background while a bottom sheet obscures the view. + has_obstacle = bool(re.search(r'bottom_sheet_container|dialog_container|dialog_root|bottom_sheet_drag', str(context_xml))) + + if not has_feed_markers or has_obstacle: + + consecutive_marker_misses += 1 + if consecutive_marker_misses >= 3: + logger.error("❌ Lost context completely or stuck behind un-clearable obstacle. Aborting feed loop to force reset.") + + + dump_ui_state(device, "context_lost", {"feed": job_target, "misses": consecutive_marker_misses, "obstacle": has_obstacle}) + return "CONTEXT_LOST" + + if consecutive_marker_misses == 2: + logger.warning( + "⚠ī¸ [FSD Anomaly Handler] Hardware 'Back' button failed to clear obstacle. Engaging VLM to find escape route...", + extra={"color": f"{Fore.YELLOW}"} + ) + telepathic = TelepathicEngine.get_instance() + best_node = telepathic.find_best_node(context_xml, intent_description="Dismiss Obstacle/Modal", device=device) + + if best_node: + logger.info(f" -> Recovery attempt! Clicking {best_node.get('semantic', 'Dismiss Button')} at ({best_node['x']}, {best_node['y']})") + device.deviceV2.click(best_node["x"], best_node["y"]) + sleep(2.5) + + # Verification: Check if markers are now visible + post_recovery_xml = device.deviceV2.dump_hierarchy() + if any(marker in post_recovery_xml for marker in FEED_MARKERS): + logger.info("✅ [Recovery] Obstacle cleared successfully. Learning this button works.") + telepathic.confirm_click("Dismiss Obstacle/Modal") + consecutive_marker_misses = 0 + continue + else: + logger.warning("⚠ī¸ [Recovery] Click failed to clear obstacle. Learning from failure.") + telepathic.reject_click("Dismiss Obstacle/Modal") + # Fallback to scroll + + logger.warning("⚠ī¸ [FSD Anomaly Handler] No viable escape route found. Forcing scroll...") + _humanized_scroll(device) + sleep(random.uniform(1.0, 2.0) * sleep_mod) + continue + + logger.warning( + "⚠ī¸ [Self-Check] NOT on a post! Open sheet or keyboard blocking view? Pressing BACK then scrolling...", + extra={"color": f"{Fore.YELLOW}"} + ) + # Dismiss any open sheets (like the comment sheet) or keyboard + device.deviceV2.press("back") + sleep(0.5) + _humanized_scroll(device) + sleep(random.uniform(1.0, 2.0) * sleep_mod) + continue + + consecutive_marker_misses = 0 + + # ── Perfect Snapping Enforcer ── + # Fixes the issue where UI gets stuck halfway between two posts. + if _align_active_post(device): + # Update context_xml because the screen just shifted + context_xml = device.deviceV2.dump_hierarchy() + if cognitive_stack.get("radome"): + context_xml = cognitive_stack.get("radome").sanitize_xml(context_xml) + + # ── Structural Ad Detection (Language-Agnostic) ── + if _detect_ad_structural(context_xml): + consecutive_ads += 1 + if consecutive_ads >= 3: + logger.warning("đŸ“ē [Anti-Stuck] Stuck on ad! Executing aggressive mechanical drag.", extra={"color": f"{Fore.RED}"}) + # Massive slow drag from top to bottom (finger down to up -> screen moves down? No we want to go down in feed so finger moves UP) + # h * 0.8 to h * 0.1 + info = device.get_info() + w, h = info.get("displayWidth", 1080), info.get("displayHeight", 2400) + device.deviceV2.swipe(w // 2, int(h * 0.8), w // 2, int(h * 0.2), duration=0.8) + sleep(2.0) + else: + logger.info("đŸ“ē skipping ad (structural match)...") + _humanized_scroll(device, is_skip=True) + sleep(random.uniform(0.5, 1.5) * sleep_mod) + continue + + consecutive_ads = 0 + + # ── Content Extraction (The Bot's Eyes) ── + post_data = _extract_post_content(context_xml) + + # ── Self-Correction: Did extraction actually work? ── + + + has_content = bool(post_data.get("username") or post_data.get("description")) + if not has_content: + logger.warning( + "⚠ī¸ [Self-Check] On a post but content extraction failed. Skipping.", + extra={"color": f"{Fore.YELLOW}"} + ) + dump_ui_state(device, "content_extraction_failed", {"feed": job_target}) + _humanized_scroll(device) + sleep(random.uniform(0.5, 1.2) * sleep_mod) + continue + + logger.info(f"✅ Post by @{post_data['username'] or '?'}: {post_data['description'][:60]}...", extra={"color": f"{Fore.GREEN}"}) + + # ── Carousel Swiping ── + if has_carousel_in_view(context_xml): + _interact_with_carousel(device, configs, sleep_mod, logger) + # ── Active Inference: Predict (before action) ── + if ai: + ai.predict_state(["row_feed", "button_like"]) + + # ── Resonance Engine (Real AI Content Evaluation) ── + res_score = resonance.calculate_resonance(post_data) if resonance else 0.5 + + # ── Dopamine Engine (fed with REAL resonance, not random) ── + dopamine.process_content({ + "score": res_score * 10, + "quality": "high" if res_score > 0.7 else "medium" if res_score > 0.4 else "low" + }) + + # ── Human-like Selective Skipping (Anti-Bot Drip) ── + skip_prob = 0.85 if res_score < 0.35 else 0.45 if res_score < 0.70 else 0.10 + if random.random() < 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", ""), + "action": "skip", + "resonance": res_score + }) + _humanized_scroll(device) + sleep(random.uniform(0.5, 1.2) * sleep_mod) + continue + + # ── 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", zero_engine): + sleep(random.uniform(1.2, 2.5) * sleep_mod) + _humanized_scroll(device, is_skip=True) + sleep(random.uniform(0.5, 1.5) * sleep_mod) + logger.info("🔙 [Rabbit Hole] Exiting profile back to main feed.") + device.deviceV2.press("back") + sleep(random.uniform(0.8, 1.5) * sleep_mod) + + # ── Darwin: SOLE Dwell Controller (micro-wobble + proof of resonance) ── + # Darwin handles ALL viewing time, scrolling, and wobble. No duplicate sleep. + if darwin: + darwin.execute_micro_wobble(device) + darwin.execute_proof_of_resonance( + device, + res_score, + nav_graph=nav_graph, + zero_engine=zero_engine, + configs=configs, + resonance_oracle=resonance, + username=post_data.get("username", "unknown") + ) + else: + # Absolute fallback if Darwin is not available + sleep(random.uniform(2.0, 5.0) * sleep_mod) + + # ── Interaction Engine ── + did_interact = False + did_like = False + did_comment = False + interact_chance = float(getattr(configs.args, "interact_percentage", 80)) / 100.0 + + profile_context = "" + # ── Profile Learning (Before heavy engagement) ── + target_user = post_data.get('username', 'target') + if res_score >= 0.8: + logger.info(f"đŸ•ĩī¸â€â™‚ī¸ [Profile Learning] Highly resonant post ({res_score:.2f}). Visiting @{target_user}'s profile to learn context...", extra={"color": f"{Fore.CYAN}"}) + + # Navigate to profile + if nav_graph._execute_transition("tap_post_username", zero_engine): + sleep(random.uniform(1.2, 2.5) * sleep_mod) + + # Extract context + try: + telepathic = cognitive_stack.get("telepathic") + crm = cognitive_stack.get("crm") + if telepathic: + xml_dump = device.deviceV2.dump_hierarchy() + nodes = telepathic._extract_semantic_nodes(xml_dump) + + texts = [] + for n in nodes: + t = n.get("text", "").strip() or n.get("content_desc", "").strip() + # Ignore small numbers, but keep bio/followers + if t and t not in texts and len(t) > 1: + texts.append(t) + + profile_context = " | ".join(texts[:15]) + logger.info(f"🧠 [Profile Learning] Extracted bio/stats: {profile_context[:50]}...", extra={"color": f"{Fore.GREEN}"}) + + if crm and target_user: + crm.log_profile_context(target_user, profile_context) + except Exception as e: + 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) + + # Return to feed + logger.info("🔙 [Profile Learning] Returning to main feed.") + device.deviceV2.press("back") + _wait_for_post_loaded(device) + sleep(random.uniform(1.0, 1.5) * sleep_mod) + + if random.random() < 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 res_score >= 0.35 and random.random() < likes_chance: + logger.info("❤ī¸ [Interaction] Liking post...") + success = nav_graph._execute_transition("tap_like_button", zero_engine) + if not success: + logger.debug("Telepathic Like failed, falling back to double-tap.") + info = device.get_info() + w, h = info.get("displayWidth", 1080), info.get("displayHeight", 2400) + _humanized_click(device, w // 2, h // 2, double=True, sleep_mod=sleep_mod) + session_state.totalLikes += 1 + sleep(random.uniform(1.2, 2.5) * sleep_mod) + did_interact = True + did_like = True + + # Umentscheidung (Change of mind) + if random.random() < 0.02: + logger.info("🧠 [Umentscheidung] Taking back the like.") + sleep(random.uniform(1.0, 3.0)) + # Press like button again to unlike + nav_graph._execute_transition("tap_like_button", zero_engine) + session_state.totalLikes -= 1 + did_like = False + did_interact = False + + # Comment: requires high resonance alignment + comment_chance = float(getattr(configs.args, "comment_percentage", 0)) / 100.0 + if session_state.check_limit(SessionState.Limit.COMMENTS): + comment_chance = 0.0 + + if res_score >= 0.4 and random.random() < comment_chance: + + logger.info("đŸ’Ŧ [Interaction] Entering Comment Sheet for deep engagement...") + success = nav_graph._execute_transition("tap_comment_button", zero_engine) + if success: + sleep(random.uniform(2.0, 4.0) * sleep_mod) + + # 1. Scrape Context from the comment sheet + sheet_xml = device.deviceV2.dump_hierarchy() + import xml.etree.ElementTree as ET + existing_comments = [] + comment_nodes = [] + 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 + + # --- Deep Engagement Actions (Liking and Sub-Commenting) --- + replying_to = None + telepathic = TelepathicEngine.get_instance() + try: + for idx, c_node in enumerate(comment_nodes): + if len(c_node["text"]) > 15: # Filter out short garbage + # 40% chance to like a substantive comment + if random.random() < 0.4: + # Use Telepathic to find the like button for this specific comment text + intent = f"Heart like button for comment: '{c_node['text'][:20]}...'" + xml_dump = device.deviceV2.dump_hierarchy() + like_btn = telepathic.find_best_node(xml_dump, intent, device=device) + + if like_btn and not like_btn.get("skip"): + _humanized_click(device, like_btn["x"], like_btn["y"], sleep_mod=sleep_mod) + sleep(random.uniform(0.8, 1.5)) + + # Verification: Simple XML change check + if device.deviceV2.dump_hierarchy() != xml_dump: + telepathic.confirm_click(intent) + logger.info(f"❤ī¸ [Interaction] Liked user comment: '{c_node['text'][:30]}...'") + else: + telepathic.reject_click(intent) + + # 20% chance to randomly visit commenter's profile + if random.random() < 0.2: + intent = f"Avatar profile picture for commenter: '{c_node['text'][:20]}...'" + xml_dump = device.deviceV2.dump_hierarchy() + avatar_node = telepathic.find_best_node(xml_dump, intent, device=device) + + if avatar_node: + logger.info(f"đŸĻ¸â€â™‚ī¸ [Randomization] Navigating to commenter's profile to explore...") + _humanized_click(device, avatar_node["x"], avatar_node["y"], sleep_mod=sleep_mod) + sleep(random.uniform(2.5, 4.5) * sleep_mod) + + # Verification: Did we reach a profile? + post_xml = device.deviceV2.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) + logger.info("🔙 [Randomization] Returning to comment sheet.") + device.deviceV2.press("back") + sleep(random.uniform(1.5, 3.0) * sleep_mod) + else: + telepathic.reject_click(intent) + 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: + intent = f"Reply button for comment: '{c_node['text'][:20]}...'" + xml_dump = device.deviceV2.dump_hierarchy() + reply_btn = telepathic.find_best_node(xml_dump, intent, device=device) + + if reply_btn: + _humanized_click(device, reply_btn["x"], reply_btn["y"], sleep_mod=sleep_mod) + sleep(random.uniform(1.2, 2.0)) + + # Verification: Did the screen change or input field appear? + if device.deviceV2.dump_hierarchy() != xml_dump: + telepathic.confirm_click(intent) + replying_to = c_node["text"] + logger.info(f"🔁 [Interaction] Replying directly to comment: '{replying_to[:30]}...'") + else: + telepathic.reject_click(intent) + except Exception as e: + logger.debug(f"[Interaction] Deep engagement parsing failed: {e}") + + # 2. Contextual Prompting + context_str = "\\n- ".join(existing_comments[:3]) + vibe = getattr(configs.args, "ai_vibe", "friendly") + + if replying_to: + prompt = ( + f"Reply to this Instagram comment as a '{vibe}' person.\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" + "Output ONLY the comment text, nothing else." + ) + else: + prompt = ( + f"Write an Instagram comment as a '{vibe}' person.\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" + "Output ONLY the comment text, nothing else." + ) + + try: + from GramAddict.core.llm_provider import query_llm + from GramAddict.core.stealth_typing import ghost_type + + model = getattr(configs.args, "ai_condenser_model", "google/gemini-2.5-flash-lite-preview") + url = getattr(configs.args, "ai_condenser_url", "https://openrouter.ai/api/v1/chat/completions") + response_dict = query_llm(url=url, model=model, prompt=prompt, format_json=False) + + if response_dict and "response" in response_dict: + clean_comment = response_dict["response"].strip().strip('"').strip("'") + if clean_comment and len(clean_comment) > 2: + # Tap the Edit Text field to focus keyboard + telepathic = cognitive_stack.get("telepathic") + if telepathic: + comment_box = telepathic.find_best_node(sheet_xml, "Comment input text box editfield", device=device) + if comment_box: + is_dry = getattr(configs.args, "dry_run_comments", False) + if is_dry: + logger.info(f"đŸšĢ [DRY RUN] Generated comment: '{clean_comment}'. Skipping UI injection.", extra={"color": f"{Fore.MAGENTA}"}) + sleep(1.5) + else: + device.deviceV2.click(comment_box["x"], comment_box["y"]) + sleep(random.uniform(1.2, 2.2)) + + # Verification: Did the keyboard open or cursor move to box? + # We check if the XML changed and focus is on an edittext + post_focus_xml = device.deviceV2.dump_hierarchy() + if "editText" in post_focus_xml.lower() or post_focus_xml != sheet_xml: + telepathic.confirm_click("Comment input text box editfield") + else: + telepathic.reject_click("Comment input text box editfield") + + # Inject via Ghost Keyboard + ghost_type(device, clean_comment) + + # Umentscheidung (Change of mind) + if random.random() < 0.10: + 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: + # Rapid backspace (Manual deletion) + for _ in range(len(clean_comment) + 2): + device.deviceV2.press("del") + sleep(random.uniform(0.01, 0.05)) + else: + # Press back to trigger Discard popup + device.deviceV2.press("back") + sleep(1.0) + xml_dump = device.deviceV2.dump_hierarchy() + discard_btn = telepathic.find_best_node(xml_dump, "Discard or Verwerfen popup button to cancel comment", device=device) + if discard_btn: + device.deviceV2.click(discard_btn["x"], discard_btn["y"]) + telepathic.confirm_click("Discard or Verwerfen popup button to cancel comment") + + logger.info("🔙 [Umentscheidung] Comment successfully aborted.") + sleep(2.0) + else: + # Tap Post + sleep(random.uniform(0.5, 1.5)) + pre_post_xml = device.deviceV2.dump_hierarchy() + post_btn = telepathic.find_best_node(pre_post_xml, "Post submit comment button", device=device) + if post_btn: + device.deviceV2.click(post_btn["x"], post_btn["y"]) + sleep(random.uniform(2.0, 3.5)) + + # Verification: Did the button disappear or layout change? + post_post_xml = device.deviceV2.dump_hierarchy() + # If "Post" button is gone from the area or XML changed significantly + if "button_post" not in post_post_xml.lower() or post_post_xml != pre_post_xml: + telepathic.confirm_click("Post submit comment button") + session_state.totalComments += 1 + did_comment = True + logger.info(f"✅ [Interaction] Comment deployed successfully: '{clean_comment}'", extra={"color": f"{Fore.GREEN}"}) + else: + telepathic.reject_click("Post submit comment button") + logger.warning("⚠ī¸ [Comment] Post button click didn't seem to work. Learning from failure.") + except Exception as e: + logger.error(f"❌ [Interaction] AI Comment deployment failed: {e}") + + # Safely exit the comment sheet + if "bottom_sheet_container" in device.deviceV2.dump_hierarchy(): + device.deviceV2.press("back") + sleep(1.0) + if "bottom_sheet_container" in device.deviceV2.dump_hierarchy(): + device.deviceV2.press("back") + sleep(1.0) + + 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: + logger.info("🔁 [Interaction] Reposting highly resonant content...", extra={"color": f"{Fore.CYAN}"}) + success = nav_graph._execute_transition("tap_share_button", zero_engine) + if success: + sleep(random.uniform(1.8, 3.5) * sleep_mod) + telepathic = TelepathicEngine.get_instance() + xml_dump = device.deviceV2.dump_hierarchy() + repost_btn = telepathic.find_best_node(xml_dump, "Repost interaction button with two arrows", device=device) + if repost_btn and not repost_btn.get("skip"): + _humanized_click(device, repost_btn["x"], repost_btn["y"], sleep_mod=sleep_mod) + sleep(random.uniform(2.0, 4.0) * sleep_mod) + + # Verification: Did the share menu close or repost confirmation appear? + post_xml = device.deviceV2.dump_hierarchy() + repost_success = post_xml != xml_dump or "reposted" in post_xml.lower() + + if repost_success: + telepathic.confirm_click("Repost interaction button with two arrows") + logger.info("✅ [Interaction] Content successfully reposted to feed/followers.", extra={"color": f"{Fore.GREEN}"}) + did_interact = True + else: + telepathic.reject_click("Repost interaction button with two arrows") + logger.warning("⚠ī¸ [Repost] Click failed to trigger repost. Learning from failure.") + + # Close share menu if still open + device.deviceV2.press("back") + sleep(random.uniform(1.0, 2.0) * sleep_mod) + + + # ── Parasocial CRM & SwarmProtocol ── + crm = cognitive_stack.get("crm") + session_state.add_interaction(source=post_data.get('username', 'Unknown'), succeed=did_interact, followed=False, scraped=False) + + if did_interact: + logger.info(f"DEBUG CRM logic: did_interact={did_interact}, crm={bool(crm)}, username='{post_data.get('username')}'") + if crm and post_data.get("username"): + intent_type = "comment_reply" if did_comment else "like" + crm.log_interaction(post_data["username"], intent_type) + + if swarm: + post_hash = f"{post_data['username']}_{post_data['description'][:30]}" + swarm.emit_pheromone(post_hash, "interacted") + + # ── Track outcome for GrowthBrain session learning ── + session_outcomes.append({ + "username": post_data.get("username", ""), + "action": "interact" if did_interact else "skip", + "resonance": res_score + }) + + # ── Active Inference: Evaluate prediction (after action) ── + if ai: + _wait_for_post_loaded(device, timeout=3) + post_action_xml = device.deviceV2.dump_hierarchy() + ai.evaluate_prediction(post_action_xml) + + # ── Advance to next post ── + _humanized_scroll(device) + sleep(random.uniform(0.5, 1.2) * sleep_mod) + + # ── End of session: Store learnings ── + if growth: + growth.refine_persona(session_outcomes) + + if darwin: + now = datetime.now() + duration_minutes = (now - session_state.startTime).total_seconds() / 60.0 + followers_gained = sum(session_state.totalFollowed.values()) + darwin.evaluate_session_end(duration_minutes, followers_gained) + + logger.info("🏁 [Drive] Feed loop terminated. Session over.") + return "SESSION_OVER" + + +def _run_zero_latency_search_loop(device, zero_engine, nav_graph, configs, session_state, current_target, cognitive_stack): + """ + Executes the autonomous Search & Interact logic. + """ + logger.info("🧠 [Search Engine] Initiating keyword discovery...", extra={"color": f"{Style.BRIGHT}{Fore.CYAN}"}) + + import random + from GramAddict.core.bot_flow import sleep, _humanized_click + from GramAddict.core.stealth_typing import ghost_type + + # Select search term + search_str = getattr(configs.args, "search", "") + interests_str = getattr(configs.args, "persona_interests", "") + + all_terms = [t.strip() for t in (search_str + "," + interests_str).split(",") if t.strip()] + if not all_terms: + all_terms = ["photography", "travel", "nature"] # Fail-safe + + keyword = random.choice(all_terms) + logger.info(f"🔎 Searching for keyword: '{keyword}'") + + # 1. Navigation to Search is handled by nav_graph.navigate_to("SearchFeed") or Explore + # We assume we are on the Explore tab now (Global Navigation Bar) + + try: + xml = device.deviceV2.dump_hierarchy() + telepathic = cognitive_stack.get("telepathic") + + # Find search bar + search_bar = telepathic.find_best_node(xml, "Search edit text box or magnifying glass input", device=device) + if search_bar: + _humanized_click(device, search_bar["x"], search_bar["y"]) + sleep(1.5) + ghost_type(device, keyword, speed="fast") + device.deviceV2.press("enter") + sleep(3.0) + + # 2. Pick a result (Top, Accounts, or Tags) + results_xml = device.deviceV2.dump_hierarchy() + target_result = telepathic.find_best_node(results_xml, "First relevant search result (Account or Hashtag)", device=device) + + if target_result: + logger.info(f"👉 Selecting search result: {target_result.get('semantic', 'Top result')}") + _humanized_click(device, target_result["x"], target_result["y"]) + sleep(3.0) + + # 3. If we are on a hashtag feed or account profile, start a mini-feed loop + # We reuse _run_zero_latency_feed_loop but with a special boredom multiplier + return _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session_state, f"Search:{keyword}", cognitive_stack) + + return "BOREDOM_CHANGE_FEED" + except Exception as e: + logger.error(f"⚠ī¸ [Search Engine] Failed: {e}") + return "CONTEXT_LOST" diff --git a/GramAddict/core/compiler_engine.py b/GramAddict/core/compiler_engine.py new file mode 100644 index 0000000..00d16a7 --- /dev/null +++ b/GramAddict/core/compiler_engine.py @@ -0,0 +1,98 @@ +import logging +import json +from io import BytesIO + +logger = logging.getLogger(__name__) + +class VLMCompilerEngine: + """ + Project Singularity V7: 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. + """ + def __init__(self, device): + self.device = device + + def generate_heuristic(self, intent_description: str, context_xml: str) -> dict: + """ + 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"}) + + args = getattr(self.device, "args", None) + model = getattr(args, "ai_telepathic_model", "google/gemini-3.1-flash-lite-preview") if args else "google/gemini-3.1-flash-lite-preview" + url = getattr(args, "ai_telepathic_url", "https://openrouter.ai/api/v1/chat/completions") if args else "https://openrouter.ai/api/v1/chat/completions" + use_local = "11434" in url or "localhost" in url + + simplified_xml = self._simplify_xml(context_xml) + + system_prompt = ( + "You write Python regex rules to find Android UI elements. " + "Given UI XML, find the element matching the intent. " + "Generate a regex pattern to match its resource-id.\n\n" + "OUTPUT FORMAT (JSON only):\n" + "{\"rule_type\": \"regex\", \"target_attribute\": \"resource-id\", " + "\"pattern\": \".*your_regex.*\", \"confidence\": 0.95, " + "\"reasoning\": \"brief explanation\"}\n\n" + "RULES:\n" + "- ONLY use rule_type='regex'. NEVER use xpath.\n" + "- Target resource-id for dynamic elements, not text or usernames.\n" + "- Make patterns globally reusable, not hardcoded to specific content." + ) + + user_prompt = f"TARGET INTENT: {intent_description}\n\nUI XML:\n{simplified_xml[:2000]}" + + try: + from GramAddict.core.llm_provider import query_telepathic_llm + res_text = query_telepathic_llm( + model=model, + url=url, + system_prompt=system_prompt, + user_prompt=user_prompt, + temperature=0.1, + use_local_edge=use_local + ) + + if res_text and res_text.startswith("```"): + res_text = "\n".join(res_text.strip().split("\n")[1:-1]) + + decision = json.loads(res_text) if res_text else {} + + pattern = decision.get('pattern') + if not pattern: + logger.error("Compiler LLM returned empty rule pattern. Aborting heuristic generation.") + return None + + logger.info(f"✨ [Compiler] New Heuristic Synthesized! Rule: {decision.get('rule_type')} -> {pattern}", extra={"color": "\x1b[1m\x1b[32m"}) + + if decision.get("rule_type") == "xpath": + logger.error("Compiler LLM returned 'xpath'. Rejecting rule because it causes xml.etree crashes. Will fallback/retry.") + return None + + return { + "rule_type": "regex", + "target_attribute": decision.get("target_attribute", "text"), + "pattern": pattern + } + + except Exception as e: + logger.error(f"Heuristic compilation crashed: {e}") + return None + + def _simplify_xml(self, xml_tree: str) -> str: + import xml.etree.ElementTree as ET + nodes = [] + try: + root = ET.fromstring(xml_tree) + for i, node in enumerate(root.iter("node")): + attrib = node.attrib + text = attrib.get("text", "") + desc = attrib.get("content-desc", "") + res_id = attrib.get("resource-id", "") + if text or desc or res_id: + nodes.append(f"[{i}] text='{text}' desc='{desc}' r_id='{res_id}'") + except: + pass + return "\n".join(nodes) diff --git a/GramAddict/core/config.py b/GramAddict/core/config.py new file mode 100644 index 0000000..f0381c6 --- /dev/null +++ b/GramAddict/core/config.py @@ -0,0 +1,265 @@ +import logging +import os +import sys +from datetime import datetime +from typing import Optional + +import configargparse +import yaml +from colorama import Fore, Style + +logger = logging.getLogger(__name__) + + +class Config: + def __init__(self, first_run=False, **kwargs): + if kwargs: + self.args = kwargs + self.module = True + else: + self.args = sys.argv + self.module = False + self.config = None + self.config_list = None + self.actions = {} + self.enabled = [] + self.unknown_args = [] + self.debug = False + self.device_id: Optional[str] = None + self.app_id: Optional[str] = None + self.first_run = first_run + self.username = False + + # Pre-Load Variables Needed for Script Init + if self.module: + if "debug" in self.args: + self.debug = True + if "username" in self.args: + self.username = self.args["username"] + if isinstance(self.username, list) and len(self.username) > 0: + self.username = self.username[0] + if "app_id" in self.args: + app_id = self.args["app_id"] + if app_id: + self.app_id = app_id + else: + self.app_id = "com.instagram.android" + elif "--config" in self.args: + try: + file_name = self.args[self.args.index("--config") + 1] + if not file_name.endswith((".yml", ".yaml")): + logger.error( + f"You have to specify a *.yml / *.yaml config file path (For example 'accounts/your_account_name/config.yml')! \nYou entered: {file_name}, abort." + ) + sys.exit(1) + logger.debug(get_time_last_save(file_name)) + with open(file_name, encoding="utf-8") as fin: + # preserve order of yaml + self.config_list = [line.strip() for line in fin] + fin.seek(0) + # preload config for debug and username + self.config = yaml.safe_load(fin) + except IndexError: + logger.warning( + "Please provide a filename with your --config argument. Example: '--config accounts/yourusername/config.yml'" + ) + exit(2) + except FileNotFoundError: + logger.error( + f"I can't see the file '{file_name}'! Double check the spelling or if you're calling the bot from the right folder. (You're there: '{os.getcwd()}')" + ) + exit(2) + + self.username = self.config.get("username", False) + if isinstance(self.username, list) and len(self.username) > 0: + self.username = self.username[0] + self.debug = self.config.get("debug", False) + self.app_id = self.config.get("app_id", "com.instagram.android") + else: + if "--debug" in self.args: + self.debug = True + if "--username" in self.args: + try: + self.username = self.args[self.args.index("--username") + 1] + except IndexError: + logger.warning( + "Please provide a username with your --username argument. Example: '--username yourusername'" + ) + exit(2) + if "--app-id" in self.args: + self.app_id = self.args[self.args.index("--app-id") + 1] + else: + self.app_id = "com.instagram.android" + + # Configure ArgParse + self.parser = configargparse.ArgumentParser( + config_file_open_func=lambda filename: open( + filename, "r+", encoding="utf-8" + ), + description="GramAddict Instagram Bot - Singularity V7", + ) + self.parser.add_argument( + "--config", + required=False, + help="config file path", + ) + self.parser.add_argument( + "--device", + help="device id", + ) + self.parser.add_argument( + "--app-id", + help="app id", + default="com.instagram.android", + ) + self.parser.add_argument( + "--debug", + action="store_true", + help="debug mode", + ) + self.parser.add_argument( + "--shadow-mode", + required=False, + action="store_true", + help="Enable Tesla E2E Vision 'Shadow Mode' Telemetry daemon.", + ) + + # Core Singularity Jobs + self.parser.add_argument("--feed", help="Amount of feed posts to interact with", default=None) + self.parser.add_argument("--explore", help="Amount of explore posts to interact with", default=None) + self.parser.add_argument("--reels", help="Amount of reels to interact with natively", default=None) + self.parser.add_argument("--stories", help="Amount of top-level stories to binge natively", default=None) + self.parser.add_argument("--repeat", help="Amount of times to repeat the whole process", default=None) + self.parser.add_argument("--total-sessions", help="Total amount of sessions", default="-1") + self.parser.add_argument("--working-hours", help="Working hours", default=None) + self.parser.add_argument("--time-delta-session", help="Time delta between sessions", default=None) + self.parser.add_argument("--restart-atx-agent", action="store_true", help="Restart atx agent") + self.parser.add_argument("--allow-untested-ig-version", action="store_true", help="Allow untested IG version") + self.parser.add_argument("--capture-e2e-dumps", action="store_true", help="Automatically navigate through the app and capture missing XML dumps for the test suite") + + # Interaction settings + self.parser.add_argument("--likes-count", help="Likes count", default="2-3") + self.parser.add_argument("--likes-percentage", help="Likes percentage", default="100") + self.parser.add_argument("--stories-count", help="Stories count", default="0") + self.parser.add_argument("--stories-percentage", help="Stories percentage", default="0") + + # Total Limits (Legacy names preserved for SessionState compatibility) + self.parser.add_argument("--total-likes-limit", help="Total likes limit", default="300") + self.parser.add_argument("--total-follows-limit", help="Total follows limit", default="50") + self.parser.add_argument("--total-unfollows-limit", help="Total unfollows limit", default="50") + self.parser.add_argument("--total-comments-limit", help="Total comments limit", default="10") + self.parser.add_argument("--total-pm-limit", help="Total pm limit", default="10") + self.parser.add_argument("--total-watches-limit", help="Total watches limit", default="50") + self.parser.add_argument("--total-successful-interactions-limit", help="Total successful interactions limit", default="100") + self.parser.add_argument("--total-interactions-limit", help="Total interactions limit", default="1000") + self.parser.add_argument("--total-scraped-limit", help="Total scraped limit", default="200") + self.parser.add_argument("--total-crashes-limit", help="Total crashes limit", default="5") + 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="google/gemini-2.5-flash-lite-preview") + self.parser.add_argument("--ai-model-url", "--ai-text-url", help="Primary LLM endpoint URL", default="https://openrouter.ai/api/v1/chat/completions") + self.parser.add_argument("--ai-telepathic-model", help="Text-based model for Telepathic Engine Fallbacks", default="google/gemini-3.1-flash-lite-preview") + self.parser.add_argument("--ai-telepathic-url", help="Telepathic model endpoint URL", default="https://openrouter.ai/api/v1/chat/completions") + 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-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") + + # Persona & Resonance (drives ALL content evaluation and interaction decisions) + self.parser.add_argument("--persona-interests", help="Comma-separated niche interests for content matching", default="") + self.parser.add_argument("--ai-target-audience", help="Target audience used interchangeably with persona interests", default="") + self.parser.add_argument("--interact-percentage", help="Overall interaction probability percentage", default="80") + self.parser.add_argument("--comment-percentage", help="Comment probability percentage", default="0") + self.parser.add_argument("--dry-run-comments", action="store_true", help="Generate AI comments but do not actually post them (debug/logging only)") + self.parser.add_argument("--search", help="Comma-separated keywords to search for", default="") + 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="google/gemini-2.5-flash-lite-preview") + self.parser.add_argument("--ai-condenser-url", help="URL for the condenser model", default="https://openrouter.ai/api/v1/chat/completions") + 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") + self.parser.add_argument("--ai-learn-own-profile", action="store_true", help="Learn from your own profile interactions") + self.parser.add_argument("--ai-learn-only", action="store_true", help="Run the bot in a pure read-only learning mode") + self.parser.add_argument("--ai-vibe", help="The specific vibe to extract from comments (e.g., friendly, controversial)", default="") + self.parser.add_argument("--ai-blacklist-topics", help="Comma-separated topics heavily penalized or skipped", default="") + self.parser.add_argument("--ai-quality-filter", action="store_true", help="Use AI to strictly filter the quality of posts and comments") + + # on first run, we must wait to proceed with loading + if not self.first_run: + self.parse_args() + + def parse_args(self): + if self.module: + if self.first_run: + logger.debug("Arguments used:") + if self.config: + logger.debug(f"Config used: {self.config}") + if len(self.args) == 0: + self.parser.print_help() + exit(0) + else: + if self.first_run: + logger.debug(f"Arguments used: {' '.join(sys.argv[1:])}") + if self.config: + logger.debug(f"Config used: {self.config}") + if len(sys.argv) <= 1: + self.parser.print_help() + 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() + val = v + if isinstance(v, dict): + val = "SPECIALIZED" + + cleaned_config[k.replace("-", "_")] = val + self.parser.set_defaults(**cleaned_config) + + if self.module: + arg_str = "" + for k, v in self.args.items(): + new_key = k.replace("_", "-") + new_key = f" --{new_key}" + arg_str += f"{new_key} {v}" + self.args, self.unknown_args = self.parser.parse_known_args(args=arg_str) + else: + self.args, self.unknown_args = self.parser.parse_known_args() + + self.device_id = self.args.device + + # Map actions for Singularity V7 + if getattr(self.args, "feed", None): self.enabled.append("feed") + if getattr(self.args, "explore", None): self.enabled.append("explore") + + def specialize(self, username): + if self.config is None: + return + + logger.debug(f"Specializing config for account: {username}") + for key, value in self.config.items(): + if isinstance(value, dict) and username in value: + resolved_value = value[username] + arg_name = key.replace("-", "_") + if hasattr(self.args, arg_name): + setattr(self.args, arg_name, resolved_value) + logger.info( + f"Applied override for {username}: {key} = {resolved_value}", + extra={"color": f"{Style.BRIGHT}{Fore.BLUE}"}, + ) + + # Handle the case where username itself is a list - we specialize it to the current target + self.args.username = [username] if isinstance(self.args.username, list) else username + + +def get_time_last_save(file_path) -> str: + try: + absolute_file_path = os.path.abspath(file_path) + timestamp = os.path.getmtime(absolute_file_path) + last_save = datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S") + return f"{file_path} has been saved last time at {last_save}" + except FileNotFoundError: + return f"File {file_path} not found" diff --git a/GramAddict/core/darwin_engine.py b/GramAddict/core/darwin_engine.py new file mode 100644 index 0000000..7c50cfd --- /dev/null +++ b/GramAddict/core/darwin_engine.py @@ -0,0 +1,242 @@ +import logging +import random +import os +import math +import uuid +import time +from datetime import datetime +from GramAddict.core.qdrant_memory import QdrantBase + +logger = logging.getLogger(__name__) + +class DarwinEngine(QdrantBase): + """ + Project Singularity: Continuous Bayesian Evolutionary Engine V3 (Proof of Resonance). + Determines mathematically how to act on a per-post basis, generating custom + Dwell Times and nonlinear scroll sequences to maximize the RL Reward Matrix. + """ + def __init__(self, username: str, config_path: str = "config.yml"): + self.username = username + self.config_path = config_path + super().__init__(collection_name="bot_darwin_mdp_resonance", vector_size=5) # 5 corresponds to behavior_bounds length + + # We replace naive percentages with Markovian Dwell Behaviors + self.behavior_bounds = { + "initial_dwell_sec": (1.0, 15.0, 2.0), + "scroll_velocity": (0.1, 2.0, 0.3), # 1.0 is normal + "back_swipe_prob": (0.0, 0.4, 0.1), + "profile_visit_prob": (0.0, 0.8, 0.2), + "comment_read_dwell": (0.0, 20.0, 4.0) + } + self.current_behavior = {} + + def synthesize_interaction_profile(self, target_resonance: float) -> dict: + """ + Given an AI aesthetic resonance score (0.0 to 1.0), this generates + a deterministic topological interaction behavior mathematically suited to the target. + """ + history = self._get_historical_landscape() + epsilon = 0.15 # 15% pure exploration + + if not history or random.random() < epsilon: + logger.info("đŸ§Ŧ [Darwin Engine] EXPLORE: Generating chaotic non-linear behavioral vector.") + center = {k: (v[0]+v[1])/2 for k, v in self.behavior_bounds.items()} + self.current_behavior = self._mutate(center) + else: + # Exploitation: Nearest neighbor matching the resonance profile closely + best_node = max(history, key=lambda x: x[1]) # x[1] is the Reward + best_params = best_node[0] + logger.info(f"đŸ§Ŧ [Darwin Engine] EXPLOIT: Adapting proven behavioral vector from highest Peak Reward ({best_node[1]:.2f}).") + self.current_behavior = self._mutate(best_params) + + # Modulate behavior directly by resonance + # E.g., if resonance is 0.9 (amazing post), read comments longer! + self.current_behavior["initial_dwell_sec"] *= max(0.5, target_resonance * 1.5) + self.current_behavior["profile_visit_prob"] *= max(0.2, target_resonance * 2.0) + + # Clip bounds + for k, (b_min, b_max, _) in self.behavior_bounds.items(): + self.current_behavior[k] = max(b_min, min(b_max, self.current_behavior[k])) + + return self.current_behavior + + def execute_proof_of_resonance(self, device, resonance: float, nav_graph=None, zero_engine=None, configs=None, resonance_oracle=None, username=None): + """ + Translates the mathematical interaction profile directly into device actions + to prove engagement to the platform's anti-bot heuristic algorithm. + """ + profile = self.synthesize_interaction_profile(resonance) + + logger.info("đŸ§Ŧ [Darwin MDP] Executing Proof of Resonance Sequence...") + + # 1. Initial Dwell + dwell = profile["initial_dwell_sec"] + logger.debug(f" -> Dwelling for {dwell:.1f}s") + time.sleep(dwell) + + # 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 + + # Keep distance microscopic (0.1 to 0.3 cm) so we DO NOT lose visual alignment + distance = device.cm_to_pixels(random.uniform(0.1, 0.3)) + duration = max(0.5, 1.0 / max(0.1, profile["scroll_velocity"])) + start_y = int(cy + distance / 2) + end_y = int(cy - distance / 2) + + # Add some x-axis noise for nonlinear human realism (~0.1 cm) + noise_x = device.cm_to_pixels(random.uniform(-0.1, 0.1)) + + device.deviceV2.swipe(cx, start_y, cx + noise_x, end_y, duration=duration) + + # 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)) + 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)) + 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") + success = nav_graph._execute_transition("tap_comment_button", zero_engine) + if success: + # ---- Phase 10: RAG Comment Extraction ---- + if configs and resonance_oracle and getattr(configs.args, "ai_learn_comments", False): + # Limit scraping to 15% to avoid mechanical persistence + if random.random() < 0.05: + logger.debug(" -> Dumping UI hierarchy for Comment Extraction...") + try: + xml_data = device.deviceV2.dump_hierarchy() + t0 = time.time() + resonance_oracle.extract_and_learn_comments(xml_data, configs, author=username or "unknown") + t1 = time.time() + remaining_sleep = profile["comment_read_dwell"] - (t1 - t0) + if remaining_sleep > 0: + time.sleep(remaining_sleep) + except Exception as e: + logger.error(f" -> Comment extraction failed: {e}") + time.sleep(profile["comment_read_dwell"]) + else: + logger.debug(" -> Skipping RAG Extraction (Probabilistic Evasion)") + time.sleep(profile["comment_read_dwell"]) + else: + time.sleep(profile["comment_read_dwell"]) + # ------------------------------------------ + + logger.debug(" -> Closing comments section") + device.deviceV2.press("back") + time.sleep(1.0) + # Instead of relying on a fragile bottom_sheet_container ID, + # we verify if the feed is visible. If not, the comment sheet is still open (or keyboard). + ui_dump = device.deviceV2.dump_hierarchy() + if 'resource-id="com.instagram.android:id/row_feed"' not in ui_dump and 'resource-id="com.instagram.android:id/button_like"' not in ui_dump: + logger.debug(" -> Not back on Home feed, pressing back again to close comment sheet/keyboard") + device.deviceV2.press("back") + time.sleep(1.0) + else: + logger.debug(f" -> Could not find comment button, falling back to dwell simulation for {profile['comment_read_dwell']:.1f}s") + time.sleep(profile["comment_read_dwell"]) + else: + logger.debug(f" -> Simulating comment section processing for {profile['comment_read_dwell']:.1f}s") + time.sleep(profile["comment_read_dwell"]) + + logger.info("đŸ§Ŧ [Darwin MDP] Interaction sequence completed safely.") + return profile + + def execute_micro_wobble(self, device): + """ + Simulates a thumb resting or slightly shifting on the glass. + Essential for breaking the 'robotically still' dwell periods. + """ + if random.random() < 0.2: # 20% chance for a wobble during dwell + logger.debug("đŸ§Ŧ [Ghost Protocol] Micro-Wobble triggered.") + info = device.get_info() + w = info.get("displayWidth", 1080) + h = info.get("displayHeight", 2400) + 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)) + + # 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)) + + def _get_historical_landscape(self): + try: + records = self.client.scroll( + collection_name=self.collection_name, + limit=1000, + with_payload=True + )[0] + return [(r.payload.get("params", {}), r.payload.get("reward", 0.0)) for r in records] + except Exception: + return [] + + def _mutate(self, base_params: dict) -> dict: + new_params = {} + for key, (p_min, p_max, volatility) in self.behavior_bounds.items(): + base_val = base_params.get(key, (p_min + p_max) / 2) + mutation = random.gauss(0, volatility) + new_params[key] = round(base_val + mutation, 3) + return new_params + + def select_arm_and_apply(self, args): + """ + Multi-Armed Bandit (MAB) logic to select the most promising behavioral + mutation strategy for the current account phase. + """ + logger.info(f"đŸ§Ŧ [Darwin Engine] Applying MDP State channel for @{self.username}...") + self.synthesize_interaction_profile(target_resonance=0.5) # Initial neutral bias + + def evaluate_session_end(self, duration_minutes: float, followers_gained: int): + if duration_minutes <= 0: duration_minutes = 1.0 + reward = (followers_gained / duration_minutes) * 10.0 + logger.info(f"đŸ§Ŧ [Darwin Engine] Session Evaluation: {followers_gained} followers gained in {duration_minutes:.1f}m. Reward: {reward:.2f}") + self.emit_reward_signal(followers_gained=followers_gained, block_warnings_seen=0) + + def emit_reward_signal(self, followers_gained: int, block_warnings_seen: int): + if not self.current_behavior: + return + + try: + reward = followers_gained - (block_warnings_seen * 50) + + vector = [] + for k, (p_min, p_max, _) in self.behavior_bounds.items(): + val = self.current_behavior.get(k, p_min) + norm = (val - p_min) / max(0.1, (p_max - p_min)) + vector.append(norm) + + p_id = str(uuid.uuid4()) + self.upsert_point( + seed_string=p_id, + vector=vector, + payload={ + "username": self.username, + "timestamp": datetime.now().isoformat(), + "params": self.current_behavior, + "reward": reward + }, + log_success=f"đŸ§Ŧ [Darwin Engine V3] MDP Reward Matrix stored. Reward Value: {reward:.2f}" + ) + except Exception as e: + logger.debug(f"đŸ§Ŧ [Darwin Engine] Failed to record reward: {e}") + diff --git a/GramAddict/core/device_facade.py b/GramAddict/core/device_facade.py new file mode 100644 index 0000000..15a50d5 --- /dev/null +++ b/GramAddict/core/device_facade.py @@ -0,0 +1,174 @@ +import logging +import json +import uiautomator2 as u2 +from time import sleep +from random import uniform +from GramAddict.core.utils import random_sleep +from functools import wraps + +logger = logging.getLogger(__name__) + +def adb_retry(retries=3, delay=2.0): + def decorator(func): + @wraps(func) + def wrapper(self, *args, **kwargs): + last_err = None + for attempt in range(retries): + try: + return func(self, *args, **kwargs) + except Exception as e: + last_err = e + logger.warning(f"⚠ī¸ ADB Error in {func.__name__} (Attempt {attempt+1}/{retries}): {e}") + sleep(delay * (attempt + 1)) # Exponential backoff + logger.error(f"❌ ADB action {func.__name__} failed after {retries} retries. Crashing gracefully.") + raise last_err + return wrapper + return decorator + +def create_device(device_id, app_id, args=None): + try: + 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 should raise so the orchestrator knows it's a fatal boot error. + raise e + +def get_device_info(device): + if not device or not device.deviceV2: + logger.error("Cannot get device info: Device not initialized.") + return + info = device.deviceV2.info + logger.debug(f"Device Info: {info.get('productName')} | SDK: {info.get('sdkInt')}") + +class DeviceFacade: + def __init__(self, device_id, app_id, args): + self.device_id = device_id + self.app_id = app_id + self.args = args + self.deviceV2 = u2.connect(device_id) + + # Configure uiautomator2 + self.deviceV2.settings["wait_timeout"] = 3.0 + self.deviceV2.settings["post_delay"] = 0.5 + + # System dialog handler (language-agnostic via resource-id, not text) + try: + # u2 v3.x: named watchers with xpath selectors + # android:id/aerr_close = App crash "Close" button (all languages) + self.deviceV2.watcher("crash_dialog").when( + xpath='//*[@resource-id="android:id/aerr_close"]' + ).click() + # android:id/button1 = positive system dialog button (all languages) + self.deviceV2.watcher("system_dialog").when( + xpath='//*[@resource-id="android:id/button1"]' + ).click() + self.deviceV2.watcher.start() + except Exception as e: + logger.debug(f"Could not start system watcher: {e}") + + @adb_retry() + def get_info(self): + return self.deviceV2.info + + @adb_retry() + def cm_to_pixels(self, cm: float) -> int: + info = self.deviceV2.info + dpx = info.get("displaySizeDpX", 400) + width = info.get("displayWidth", 1080) + # Android baseline: 1 dp = 1/160 inch. 1 inch = 2.54 cm + # PPCM (Pixels Per CM) = (width / dpx) * (160 / 2.54) + ppcm = (width / dpx) * (160 / 2.54) + return int(cm * ppcm) + + @adb_retry() + def wake_up(self): + if not self.deviceV2.info.get("screenOn"): + self.deviceV2.screen_on() + self.deviceV2.press("home") + sleep(1) + + @adb_retry() + def press(self, key): + self.deviceV2.press(key) + + @adb_retry() + def click(self, x=None, y=None, obj=None): + if obj: + if isinstance(obj, dict) and 'x' in obj and 'y' in obj: + self.human_click(obj['x'], obj['y']) + return + try: + left, top, right, bottom = obj.bounds() + cx = (left + right) // 2 + cy = (top + bottom) // 2 + from random import uniform + # Randomize hit location within inner 50% of the UI element + w = right - left + h = bottom - top + cx += int(uniform(-w * 0.25, w * 0.25)) + cy += int(uniform(-h * 0.25, h * 0.25)) + self.human_click(cx, cy) + except Exception as e: + logger.debug(f"Bounds extraction failed, fallback to native click: {e}") + obj.click() + elif x is not None and y is not None: + self.human_click(x, y) + + @adb_retry() + def human_click(self, x, y): + from random import uniform + try: + self.deviceV2.touch.down(x, y) + # Human finger rest time (squish) + sleep(uniform(0.05, 0.15)) + + # Sloppy slip + slip_x = x + int(uniform(-4, 4)) + slip_y = y + int(uniform(-4, 4)) + self.deviceV2.touch.move(slip_x, slip_y) + + sleep(uniform(0.01, 0.05)) + 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) + + @adb_retry() + def swipe_points(self, x1, y1, x2, y2, duration=0.1): + self.deviceV2.swipe(x1, y1, x2, y2, duration) + + @adb_retry() + def human_swipe(self, start_x, start_y, end_x, end_y, duration=0.3): + # Simulate a realistic human swipe by keeping it simple. + # 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) + + @adb_retry() + def _get_current_app(self): + return self.deviceV2.app_current().get("package") + + @adb_retry() + def find(self, **kwargs): + """Standard uiautomator2 find.""" + return self.deviceV2(**kwargs) + + @adb_retry() + def dump_hierarchy(self): + return self.deviceV2.dump_hierarchy() + + @adb_retry() + def screenshot(self): + return self.deviceV2.screenshot() + + # Telepathic Semantic UI Integration + @adb_retry() + def find_semantic(self, intent_description: str): + from GramAddict.core.telepathic_engine import TelepathicEngine + engine = TelepathicEngine.get_instance() + xml = self.dump_hierarchy() + # Passing self (DeviceFacade) enables the Vision Cortex VLM fallback + node = engine.find_best_node(xml, intent_description, device=self) + return node diff --git a/GramAddict/core/diagnostic_dump.py b/GramAddict/core/diagnostic_dump.py new file mode 100644 index 0000000..1d4283e --- /dev/null +++ b/GramAddict/core/diagnostic_dump.py @@ -0,0 +1,107 @@ +""" +Diagnostic XML Dumper for Project Singularity +============================================== +Automatically captures UI hierarchy snapshots when the bot encounters +problematic states. These dumps serve as future test fixtures for TDD. + +Dumps are saved to `debug/xml_dumps/` with timestamped filenames +and a structured reason tag for easy triage. + +Retention: Keeps the last 50 dumps per reason category to avoid disk bloat. +""" +import os +import logging +import json +from datetime import datetime + +logger = logging.getLogger(__name__) + +DUMP_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "debug", "xml_dumps") +MAX_DUMPS_PER_CATEGORY = 50 + + +def dump_ui_state(device, reason: str, extra_context: dict = None): + """ + Capture and save the current UI hierarchy to disk for debugging. + + Args: + device: The uiautomator2 device facade. + reason: Short tag for the failure type. Used for filename grouping. + Examples: 'context_lost', 'vlm_hallucination', 'nav_failure', + 'stuck_on_post', 'unexpected_screen' + extra_context: Optional dict with additional metadata (intent, expected state, etc.) + """ + try: + os.makedirs(DUMP_DIR, exist_ok=True) + + # Capture hierarchy + xml = device.deviceV2.dump_hierarchy() + + # Generate filename: reason__2026-04-13_17-41-39.xml + ts = datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + safe_reason = reason.replace(" ", "_").replace("/", "_")[:40] + filename = f"{safe_reason}__{ts}.xml" + filepath = os.path.join(DUMP_DIR, filename) + + # Write XML + with open(filepath, "w", encoding="utf-8") as f: + f.write(xml) + + # Write companion metadata JSON + meta = { + "reason": reason, + "timestamp": ts, + "xml_file": filename, + } + # Capture the session log if available + try: + import shutil + from GramAddict.core.log import get_log_file_config + log_name, log_dir, _, _ = get_log_file_config() + if log_name and log_dir: + active_log = os.path.join(log_dir, log_name) + if os.path.exists(active_log): + log_dest = filepath.replace(".xml", ".log") + shutil.copy2(active_log, log_dest) + meta["log_file"] = os.path.basename(log_dest) + except Exception as e: + logger.debug(f"[Diagnostic] Could not capture session log: {e}") + + if extra_context: + meta["context"] = extra_context + + meta_path = filepath.replace(".xml", ".meta.json") + with open(meta_path, "w", encoding="utf-8") as f: + json.dump(meta, f, indent=2, ensure_ascii=False) + + logger.info(f"📸 [Diagnostic] UI state and session log dumped for '{reason}': {filepath}") + + # Rotate old dumps for this category + _rotate_dumps(safe_reason) + + return filepath + + except Exception as e: + # Dumping must NEVER crash the bot + logger.debug(f"[Diagnostic] Could not dump UI state: {e}") + return None + + +def _rotate_dumps(category_prefix: str): + """Keep only the last MAX_DUMPS_PER_CATEGORY dumps per category.""" + try: + all_files = sorted([ + f for f in os.listdir(DUMP_DIR) + if f.startswith(category_prefix) and f.endswith(".xml") + ]) + + if len(all_files) > MAX_DUMPS_PER_CATEGORY: + files_to_remove = all_files[:len(all_files) - MAX_DUMPS_PER_CATEGORY] + for f in files_to_remove: + xml_path = os.path.join(DUMP_DIR, f) + meta_path = xml_path.replace(".xml", ".meta.json") + os.remove(xml_path) + if os.path.exists(meta_path): + os.remove(meta_path) + except Exception: + pass diff --git a/GramAddict/core/dm_engine.py b/GramAddict/core/dm_engine.py new file mode 100644 index 0000000..a00880c --- /dev/null +++ b/GramAddict/core/dm_engine.py @@ -0,0 +1,113 @@ +import logging +import random +from colorama import Fore, Style +from GramAddict.core.session_state import SessionState + +logger = logging.getLogger(__name__) + +def _run_zero_latency_dm_loop(device, zero_engine, nav_graph, configs, session_state, current_target, cognitive_stack): + """ + Executes the autonomous Direct Messaging logic in the Zero-Latency architecture. + Assumes the bot is already at the "MessageInbox" UI state. + """ + logger.info(f"🧠 [DM Engine] Initiating inbox processing in {current_target}...", extra={"color": f"{Style.BRIGHT}{Fore.CYAN}"}) + + telepathic = cognitive_stack.get("telepathic") + dopamine = cognitive_stack.get("dopamine") + crm = cognitive_stack.get("crm") + + from GramAddict.core.bot_flow import sleep, dump_ui_state, _humanized_click + from GramAddict.core.llm_provider import query_llm + from GramAddict.core.stealth_typing import ghost_type + + # Initialize session limits if missing + if not hasattr(session_state, 'totalMessages'): + session_state.totalMessages = 0 + + failed_attempts = 0 + + while not dopamine.is_app_session_over(): + # Limits check + limit_val = session_state.check_limit(SessionState.Limit.PM) + if isinstance(limit_val, tuple) and limit_val[0]: + logger.info("🛑 Messaging limit reached for session.") + return "BOREDOM_CHANGE_FEED" + elif limit_val is True: + return "BOREDOM_CHANGE_FEED" + + try: + xml_dump = device.deviceV2.dump_hierarchy() + + # Step 1: Find unread conversation threads + unread_threads = telepathic._extract_semantic_nodes(xml_dump, "find unread message threads or unread badges", threshold=0.7) + + if unread_threads and not unread_threads[0].get("skip"): + target_node = unread_threads[0] + logger.info(f"📨 Found unread message thread. Opening.") + _humanized_click(device, target_node["x"], target_node["y"]) + sleep(2.0) + + # Step 2: Read the conversation context + thread_xml = device.deviceV2.dump_hierarchy() + msg_nodes = telepathic._extract_semantic_nodes(thread_xml, "find the last received message text", threshold=0.6) + + context_text = "No previous context" + if msg_nodes and not msg_nodes[0].get("skip") and msg_nodes[0].get("text"): + context_text = msg_nodes[0].get("text") + + logger.debug(f"Last received message context: {context_text}") + + # Verify we aren't at limits before sending + if not getattr(configs.args, "disable_ai_messaging", False): + # 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: + # 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"): + in_node = input_nodes[0] + _humanized_click(device, in_node["x"], in_node["y"]) + sleep(1.0) + + # Type the message + ghost_type(device, response_text, speed="fast") + sleep(1.0) + + # Find Send button + send_xml = device.deviceV2.dump_hierarchy() + send_nodes = telepathic._extract_semantic_nodes(send_xml, "find the send message button", threshold=0.8) + + if send_nodes and not send_nodes[0].get("skip"): + s_node = send_nodes[0] + _humanized_click(device, s_node["x"], s_node["y"]) + logger.info("✅ [DM Engine] Successfully sent a generated reply.", extra={"color": Fore.GREEN}) + + session_state.totalMessages += 1 + if crm: + crm.log_sent_dm("unknown_target", response_text, "", []) + + # Return back to inbox + device.deviceV2.press("back") + sleep(1.0) + + dopamine.boredom += random.uniform(5.0, 15.0) + failed_attempts = 0 + else: + logger.info("📭 No unread threads found. Inbox clear.") + dopamine.boredom += 50.0 # Inbox clear = massive boredom = change feed + + if dopamine.wants_to_change_feed() or dopamine.boredom >= 100: + logger.info("🧠 [DM Engine] Interaction complete. Transitioning back from inbox.") + device.deviceV2.press("back") # Go back from inbox + return "BOREDOM_CHANGE_FEED" + + except Exception as e: + logger.error(f"⚠ī¸ [FSD Anomaly Handler] Exception in DM Loop: {e}") + device.deviceV2.press("back") + failed_attempts += 1 + if failed_attempts > 2: + return "CONTEXT_LOST" + + return "SESSION_OVER" diff --git a/GramAddict/core/dojo_engine.py b/GramAddict/core/dojo_engine.py new file mode 100644 index 0000000..fa19789 --- /dev/null +++ b/GramAddict/core/dojo_engine.py @@ -0,0 +1,95 @@ +import logging +import threading +import time +import os +import queue +from datetime import datetime +from colorama import Fore + +# Import existing VLM engine and Qdrant DB for operations +from GramAddict.core.compiler_engine import VLMCompilerEngine +from GramAddict.core.qdrant_memory import HeuristicMemoryDB + +logger = logging.getLogger(__name__) + +class DojoEngine: + """ + Project Dojo: The Tesla FSD 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 + heuristic using a heavy VLM model in the background and updates the DB. + "Never make a mistake twice." + """ + _instance = None + + @classmethod + def get_instance(cls, device=None): + if cls._instance is None: + if device is None: + raise ValueError("DojoEngine must be initialized with a device first.") + cls._instance = DojoEngine(device) + return cls._instance + + def __init__(self, device): + self.learning_queue = queue.Queue() + self.compiler = VLMCompilerEngine(device) + self.db = HeuristicMemoryDB() + self.is_running = False + self.worker_thread = None + + def start(self): + if not self.is_running: + self.is_running = True + self.worker_thread = threading.Thread(target=self._process_queue, daemon=True) + self.worker_thread.start() + logger.info("⛩ī¸ [Dojo Data Engine] Background learning pipeline initialized.", extra={"color": f"{Fore.CYAN}"}) + + def stop(self): + self.is_running = False + if self.worker_thread: + self.worker_thread.join(timeout=2.0) + + def submit_snapshot(self, heuristic_name: str, context_xml: str, intent_prompt: str): + """ + Submits a failed UI state to the Dojo for background recompilation. + """ + snapshot = { + "name": heuristic_name, + "xml": context_xml, + "intent": intent_prompt, + "timestamp": datetime.now().isoformat() + } + self.learning_queue.put(snapshot) + logger.info(f"⛩ī¸ [Dojo] Snapshot for '{heuristic_name}' enqueued for shadow-compilation.", extra={"color": f"{Fore.CYAN}"}) + + def _process_queue(self): + """ + The background worker loop. + """ + while self.is_running: + try: + # Wait for a job + snapshot = self.learning_queue.get(timeout=5.0) + h_name = snapshot['name'] + xml = snapshot['xml'] + intent = snapshot['intent'] + + logger.info(f"⛩ī¸ [Dojo] Processing auto-labeling job: {h_name}...", extra={"color": f"{Fore.CYAN}"}) + + # Heavy compilation + new_rule = self.compiler.generate_heuristic(intent, xml) + + if new_rule: + # Overwrite legacy rule in Database (Fleet update) + self.db.cache_heuristic(h_name, new_rule) + logger.info(f"⛩ī¸ [Dojo] SUCCESS! Fleet Memory updated with robust heuristic for '{h_name}'.", extra={"color": f"{Fore.GREEN}"}) + else: + logger.warning(f"⛩ī¸ [Dojo] FAILED to compile robust heuristic for '{h_name}'.", extra={"color": f"{Fore.RED}"}) + + self.learning_queue.task_done() + + except queue.Empty: + continue + except Exception as e: + logger.error(f"⛩ī¸ [Dojo] Auto-labeling crashed: {e}") diff --git a/GramAddict/core/dopamine_engine.py b/GramAddict/core/dopamine_engine.py new file mode 100644 index 0000000..e3a0b29 --- /dev/null +++ b/GramAddict/core/dopamine_engine.py @@ -0,0 +1,75 @@ +import logging +import random +import time +from colorama import Fore + +logger = logging.getLogger(__name__) + +class DopamineEngine: + """ + Simulation of human neurochemistry. + Manages boredom levels and interest-based interaction pacing. + """ + def __init__(self): + self.boredom = 0.0 # 0.0 to 100.0 + self.spike_threshold = 7.0 + self.homeostasis_rate = 0.05 # decay per minute + self.last_spike = time.time() + self.session_start = time.time() + self.session_limit_seconds = random.uniform(10 * 60, 35 * 60) # 10-35 mins session + + def process_content(self, classification: dict): + """ + classification: {'quality': 'high'|'low', 'type': 'meme'|'aesthetic'|'ad', 'score': 0-10} + """ + score = classification.get("score", 5.0) + quality = classification.get("quality", "medium") + + # Calculate spike + spike = score * 1.5 if quality == "high" else score * 0.5 + + # Update boredom: negative correlation with high quality content + if spike > self.spike_threshold: + self.boredom = max(0.0, self.boredom - (spike * 0.2)) + logger.info(f"💉 [Dopamine] Spike detected! Interest high. Boredom decreased to {self.boredom:.1f}%", extra={"color": f"{Fore.YELLOW}"}) + else: + self.boredom = min(100.0, self.boredom + 5.0) + logger.info(f"💉 [Dopamine] Low interest content. Boredom increased to {self.boredom:.1f}%", extra={"color": f"{Fore.YELLOW}"}) + + self.last_spike = time.time() + return self.is_bored() + + def is_bored(self): + return self.boredom >= 100.0 + + 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 + + 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 + + def get_pacing_modifier(self, base_score: float): + """ + Returns a multiplier for sleep durations. + High dopamine (high interest) = longer viewing time. + """ + if base_score > 8: + return random.uniform(2.0, 4.0) # Entranced + if base_score < 3: + return random.uniform(0.1, 0.4) # Fast-swipe + return 1.0 + + def decay(self): + """ + Called periodically to return to baseline. + """ + now = time.time() + minutes = (now - self.last_spike) / 60.0 + self.boredom = min(100.0, self.boredom + (minutes * self.homeostasis_rate)) + self.last_spike = now diff --git a/GramAddict/core/dump_capturer.py b/GramAddict/core/dump_capturer.py new file mode 100644 index 0000000..e00e2bf --- /dev/null +++ b/GramAddict/core/dump_capturer.py @@ -0,0 +1,105 @@ +import os +import time +import logging + + +logger = logging.getLogger(__name__) + +def capture_all(device): + """ + Automated E2E Dump Capturer Sequence. + Navigates through the Instagram UI and securely saves exact XML representations + to satisfy the `e2e_device_dump_injector` test requirements. + + Warning: Requires a logged-in session and active device connection. + """ + logger.info("📸 Initiating E2E Dump Capture Sequence!") + + FIX_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "tests", "fixtures") + os.makedirs(FIX_DIR, exist_ok=True) + + def _save_dump(filename, description): + logger.info(f"âŗ Waiting for UI to settle for [{description}]...") + time.sleep(3.5) # ensure animations finish + xml_data = device.deviceV2.dump_hierarchy() + path = os.path.join(FIX_DIR, filename) + with open(path, "w", encoding="utf-8") as f: + f.write(xml_data) + logger.info(f"✅ Saved ECHTEN DUMP to {filename}") + + print("\n" + "="*50) + print("🤖 MANUAL E2E DUMP CAPTURE SEQUENCE") + print("="*50) + print("Please follow the instructions below to capture the required fixtures.") + print("If an IG update changed the layout, you can navigate there naturally.") + print("="*50 + "\n") + + try: + # Pre-condition: Device connected + logger.info("Verifying device connection...") + device.deviceV2.info + + # 1. Comment Sheet + input("\n👉 1. COMMENT SHEET:\nOpen Instagram, scroll to any post on the HomeFeed, and open the comment section.\nWhen the comment sheet is fully visible, press ENTER to capture...") + _save_dump("comment_sheet.xml", "Post Comment Sheet") + + # 2. Stories Feed + input("\n👉 2. STORIES FEED:\nGo to the HomeFeed and tap any user's story right at the top.\nWhile the story is playing (video/photo is visible), press ENTER to capture...") + _save_dump("stories_feed_dump.xml", "Active Story Playback") + + # 3. DM Inbox + input("\n👉 3. DM INBOX:\nGo back to the HomeFeed and tap the message icon in the top right to open your inbox.\nWhen your list of chats is visible, press ENTER to capture...") + _save_dump("dm_inbox_dump.xml", "DM Inbox / Threads List") + + # 4. Profile Scraping & Unfollow List + input("\n👉 4. OWN PROFILE:\nGo to your OWN profile by tapping your avatar in the bottom right corner.\nWhen your bio and grid are fully visible, press ENTER to capture...") + _save_dump("scraping_profile_dump.xml", "Own Profile Root (User Info)") + + input("\n👉 4.b FOLLOWING LIST:\nFrom your profile, tap your 'Following' (Abonniert) count to open the list of people you follow.\nWhen the list is fully loaded, press ENTER to capture...") + _save_dump("unfollow_list_dump.xml", "Following List Iteration View") + + # 5. Search Feed + input("\n👉 5. EXPLORE SEARCH:\nTap the magnifying glass (Explore) tab at the bottom. Then, tap into the top 'Search' bar so your keyboard opens.\nWhen you are in the search state, press ENTER to capture...") + _save_dump("search_feed_dump.xml", "Explore Search Input Focus") + + # 6. Reels Feed + input("\n👉 6. REELS FEED:\nTap the Reels (Video) tab at the bottom center. Let a video start playing.\nPress ENTER to capture...") + _save_dump("reels_feed_dump.xml", "Reels Video Feed") + + # 7. Notifications + input("\n👉 7. NOTIFICATIONS (ACTIVITY):\nGo to the HomeFeed and tap the Heart icon in the top right to open notifications.\nPress ENTER to capture...") + _save_dump("notifications_dump.xml", "Activity / Notifications tab") + + # 8. Explore Grid + input("\n👉 8. EXPLORE GRID:\nTap the magnifying glass (Explore) tab, but do NOT tap the search bar.\nWhen the grid of images/videos is visible, press ENTER to capture...") + _save_dump("explore_feed_dump.xml", "Explore Discovery Grid") + + # 9. Other User's Profile + input("\n👉 9. ALIEN PROFILE:\nNavigate to ANY OTHER user's profile (e.g. from your Feed or Search).\nWhen their bio and grid are visible, press ENTER to capture...") + _save_dump("user_profile_dump.xml", "Alien Profile Root") + + # 10. Followers List + input("\n👉 10. FOLLOWERS LIST:\nFrom that profile (or your own), tap the 'Followers' (Abonnenten) count.\nWhen the list of followers is visible, press ENTER to capture...") + _save_dump("followers_list_dump.xml", "Followers List Iteration View") + + # 11. Carousel Post + input("\n👉 11. CAROUSEL POST:\nScroll your Feed until you see a Carousel (a post with multiple swipable images/videos).\nWhen it is visible, press ENTER to capture...") + _save_dump("carousel_post_dump.xml", "Carousel Post Wrapper") + + # 12. Sponsored Post / Ad + input("\n👉 12. SPONSORED AD:\nScroll your Feed or Stories until you see a Sponsored / Gesponsert Post with an action button.\nWhen the Ad is visible, press ENTER to capture...") + _save_dump("home_feed_with_ad.xml", "Sponsored Ad Post") + + # 13. Inside DM Chat + input("\n👉 13. DM CHAT THREAD:\nOpen any message thread in your DM inbox.\nWhen the chat messages and text input field are visible, press ENTER to capture...") + _save_dump("dm_thread_dump.xml", "Direct Message Chat Thread") + + print("\n" + "="*50) + logger.info("🎉 Capture Sequence Complete! All 13 E2E dumps have been placed into tests/fixtures/") + print("="*50 + "\n") + + except KeyboardInterrupt: + print("\n") + logger.info("🛑 Capture Sequence Interrupted by User.") + except Exception as e: + logger.error(f"đŸ’Ĩ Capture Sequence crashed: {e}", exc_info=True) diff --git a/GramAddict/core/growth_brain.py b/GramAddict/core/growth_brain.py new file mode 100644 index 0000000..f9db990 --- /dev/null +++ b/GramAddict/core/growth_brain.py @@ -0,0 +1,99 @@ +import logging +import random +from datetime import datetime +from colorama import Fore + +from GramAddict.core.qdrant_memory import PersonaMemoryDB + +logger = logging.getLogger(__name__) + +class GrowthBrain: + """ + Biological Feedback and Persona Management. + + Two critical functions: + 1. Circadian Rhythm — modulates ALL sleep/dwell times based on time of day + 2. Persona Refinement — learns from interaction outcomes and stores insights + """ + def __init__(self, username: str, persona_interests: list[str] = None): + self.username = username + self.persona_memory = PersonaMemoryDB() + self.persona_interests = persona_interests or [] + self.last_learning_at = datetime.now() + + def get_circadian_pacing(self) -> float: + """ + Adjusts activity levels based on the current local time + to simulate human sleep/wake cycles. + + Returns a multiplier (0.1 to 1.0) that should be applied to ALL sleep durations. + Lower = slower (more human-like during off-hours). + """ + hour = datetime.now().hour + + # Determine current pacing state + if 2 <= hour <= 5: + pacing = 0.1 + state_id = "deep_sleep" + msg = "🧠 [GrowthBrain] Deep sleep mode. Performance 10%." + elif 6 <= hour <= 7: + pacing = 0.4 + state_id = "waking_up" + msg = "🧠 [GrowthBrain] Waking up slowly. Performance 40%." + elif 8 <= hour <= 9: + pacing = 0.7 + state_id = "morning_warmup" + msg = "🧠 [GrowthBrain] Morning warmup. Performance 70%." + elif hour >= 23 or hour <= 1: + pacing = 0.5 + state_id = "evening_winddown" + msg = "🧠 [GrowthBrain] Evening wind-down. Performance 50%." + else: + pacing = 1.0 + state_id = "peak_hours" + msg = "🧠 [GrowthBrain] Peak metabolic rate. Performance 100%." + + # Log intelligently (only info log on state change) + if not hasattr(self, '_last_pacing_state') or getattr(self, '_last_pacing_state') != state_id: + logger.info(msg, extra={"color": f"{Fore.GREEN}"}) + self._last_pacing_state = state_id + else: + logger.debug(msg) + + return pacing + + def refine_persona(self, interaction_outcomes: list[dict]): + """ + Learns from interaction outcomes to refine persona understanding. + + interaction_outcomes: [{'username': str, 'action': 'like'|'comment'|'skip', 'resonance': float}] + + Stores high-performing interaction patterns in PersonaMemoryDB. + """ + if not interaction_outcomes: + return + + # Find interactions that had high resonance (those are our niche) + high_res = [o for o in interaction_outcomes if o.get("resonance", 0) > 0.7] + low_res = [o for o in interaction_outcomes if o.get("resonance", 0) < 0.3] + + if high_res: + insight = f"High-resonance interactions in this session: {len(high_res)} posts matched niche." + self.persona_memory.store_persona_insight("session_learning", insight) + logger.info( + f"🧠 [GrowthBrain] Session learning: {len(high_res)} high-resonance, {len(low_res)} low-resonance posts.", + extra={"color": f"{Fore.GREEN}"} + ) + + self.last_learning_at = datetime.now() + + def get_persona_context(self) -> str: + """Returns learned persona context for LLM prompts.""" + base = "" + if self.persona_interests: + base = f"Core interests: {', '.join(self.persona_interests)}" + + learned = self.persona_memory.get_persona_context() + if learned: + return f"{base}\n{learned}" if base else learned + return base diff --git a/GramAddict/core/llm_provider.py b/GramAddict/core/llm_provider.py new file mode 100644 index 0000000..b9da992 --- /dev/null +++ b/GramAddict/core/llm_provider.py @@ -0,0 +1,286 @@ +import re +import os +import json +import requests +import logging +from typing import Optional, List, Dict + +try: + from dotenv import load_dotenv + load_dotenv() +except ImportError: + pass + +logger = logging.getLogger(__name__) + +def extract_json(text: str) -> Optional[str]: + """ + Robustly extracts the first JSON object or array from a string that may contain + natural language prefix/suffix. Also purges blocks and markdown ticks. + """ + if not text: + return None + + # 100% Autonomous: Scrub model's internal thinking process + if "" in text: + text = re.sub(r'.*?', '', text, flags=re.DOTALL).strip() + logger.debug("🧠 [LLM] Scoped thinking block detected and purged.") + + # Remove markdown code block formats + text = re.sub(r'^```json\s*', '', text, flags=re.MULTILINE) + text = re.sub(r'^```\s*', '', text, flags=re.MULTILINE) + + # Look for { ... } or [ ... ] + match = re.search(r'(\{.*\}|\[.*\])', text, re.DOTALL) + if match: + return match.group(0) + return None + +_MODEL_PRICING_CACHE = None + +def get_model_pricing(model_id: str) -> dict: + global _MODEL_PRICING_CACHE + if _MODEL_PRICING_CACHE is None: + try: + r = requests.get("https://openrouter.ai/api/v1/models", timeout=5) + if r.status_code == 200: + models = r.json().get("data", []) + _MODEL_PRICING_CACHE = {m["id"]: m.get("pricing", {}) for m in models} + else: + _MODEL_PRICING_CACHE = {} + except Exception: + _MODEL_PRICING_CACHE = {} + + # Check if exact match exists, if not, try partial matches (e.g., if version suffixes differ) + if _MODEL_PRICING_CACHE and model_id not in _MODEL_PRICING_CACHE: + for k, v in _MODEL_PRICING_CACHE.items(): + if model_id in k or k in model_id: + return v + + return _MODEL_PRICING_CACHE.get(model_id, {}) + +def log_openrouter_burn(): + """Fetches and logs the current OpenRouter API key usage (money burned).""" + key = os.environ.get("OPENROUTER_API_KEY") + if not key: + return + + try: + r = requests.get("https://openrouter.ai/api/v1/auth/key", headers={"Authorization": f"Bearer {key}"}, timeout=5) + if r.status_code == 200: + data = r.json().get("data", {}) + total_spent = data.get("usage", 0.0) + daily_spent = data.get("usage_daily", 0.0) + limit = data.get("limit") + + logger.info(f"đŸ”Ĩ [OpenRouter Burn Rate] Daily: ${daily_spent:.4f} | Total: ${total_spent:.4f}" + (f" | Limit: ${limit}" if limit else ""), extra={"color": "\x1b[38;5;208m\x1b[1m"}) + except Exception as e: + logger.debug(f"Could not fetch OpenRouter burn rate: {e}") + +def query_llm( + url: str, + model: str, + prompt: str, + images_b64: Optional[List[str]] = None, + system: Optional[str] = None, + format_json: bool = False, + timeout: int = 60, + fallback_model: Optional[str] = None, + fallback_url: Optional[str] = None +) -> Optional[dict]: + """ + Unified LLM API Caller with configurable fallback. + """ + openrouter_key = os.environ.get("OPENROUTER_API_KEY") + + # URL-based provider detection (not model-name based — works for any model) + is_openai_compat = "/v1/chat/completions" in url or "openrouter.ai" in url.lower() or "openai.com" in url.lower() + + # If using a cloud model but a local URL was passed, fix it + if not is_openai_compat and ("openrouter" in model.lower() or "/" in model): + # Model looks like "org/model-name" which is OpenRouter format + is_openai_compat = True + url = "https://openrouter.ai/api/v1/chat/completions" + + headers = {"Content-Type": "application/json"} + + if is_openai_compat: + if openrouter_key: + headers["Authorization"] = f"Bearer {openrouter_key}" + + messages = [] + if system: + messages.append({"role": "system", "content": system}) + + user_content = [] + if prompt: + user_content.append({"type": "text", "text": prompt}) + + if images_b64: + for img in images_b64: + user_content.append({ + "type": "image_url", + "image_url": {"url": f"data:image/jpeg;base64,{img}"} + }) + + messages.append({"role": "user", "content": user_content if len(user_content) > 1 else prompt}) + + req_data = { + "model": model, + "messages": messages, + "stream": False + } + if format_json: + req_data["response_format"] = {"type": "json_object"} + + else: + # Ollama /generate API + req_data = { + "model": model, + "prompt": prompt, + "stream": False + } + if system: + req_data["system"] = system + if images_b64: + req_data["images"] = images_b64 + if format_json: + req_data["format"] = "json" + + try: + response = requests.post(url, json=req_data, headers=headers, timeout=timeout) + response.raise_for_status() + resp_json = response.json() + + # Normalize response payload so callers don't have to distinguish + if is_openai_compat: + # OpenRouter returns choices[0].message.content + content = resp_json.get("choices", [{}])[0].get("message", {}).get("content", "") + + usage = resp_json.get("usage", {}) + if usage: + cost_str = "" + # Attempt to get precise cost sent by OpenRouter or calculate it manually + if "total_cost" in usage: + cost_str = f" | 💸 Cost: ${usage['total_cost']:.6f}" + else: + pricing = get_model_pricing(model) + if pricing: + try: + p_cost = float(pricing.get("prompt", 0)) * usage.get('prompt_tokens', 0) + c_cost = float(pricing.get("completion", 0)) * usage.get('completion_tokens', 0) + calc_cost = p_cost + c_cost + if calc_cost > 0: + cost_str = f" | 💸 Cost: ${calc_cost:.6f}" + except Exception: + pass + + p_tokens = usage.get('prompt_tokens', 0) + c_tokens = usage.get('completion_tokens', 0) + t_tokens = usage.get('total_tokens', 0) + + # Make it stand out! + logger.info(f"đŸĒ™ [LLM Burn] {model} -> In: {p_tokens} | Out: {c_tokens} | Total: {t_tokens}{cost_str}", extra={"color": "\x1b[38;5;208m\x1b[1m"}) + + # Validation: if JSON was expected, try to extract it + if format_json: + extracted = extract_json(content) + if not extracted: + raise ValueError(f"OpenRouter returned non-JSON content when JSON was expected: {content[:100]}...") + content = extracted + + return {"response": content} + else: + # Ollama returns response + content = resp_json.get("response", "") + if format_json: + extracted = extract_json(content) + if not extracted: + raise ValueError(f"Ollama returned non-JSON content when JSON was expected: {content[:100]}...") + resp_json["response"] = extracted + + return resp_json + except Exception as e: + logger.error(f"LLM Provider Error with {model}: {e}") + + # Prevent infinite fallback loops + if getattr(query_llm, "_is_fallback", False): + return None + + # Decide on fallback model/url + f_model = fallback_model + f_url = fallback_url + + # Read fallback config from args if available + if not f_model or not f_url: + from GramAddict.core.config import Config + try: + args = Config().args + f_model = f_model or getattr(args, "ai_fallback_model", None) + f_url = f_url or getattr(args, "ai_fallback_url", None) + except Exception: + pass + + # Last resort defaults + if not f_model or not f_url: + if is_openai_compat: + f_model = f_model or "llama3.2:1b" + f_url = f_url or "http://localhost:11434/api/generate" + else: + f_model = f_model or "google/gemini-2.5-flash-lite-preview" + f_url = f_url or "https://openrouter.ai/api/v1/chat/completions" + + query_llm._is_fallback = True + try: + logger.warning(f"Primary AI ({model}) failed or returned garbage. Attempting fallback to {f_model}...") + return query_llm( + url=f_url, + model=f_model, + prompt=prompt, + images_b64=images_b64, + system=system, + format_json=format_json, + timeout=timeout + ) + finally: + query_llm._is_fallback = False + return None + +def query_telepathic_llm( + model: str, + url: str, + system_prompt: str, + user_prompt: str, + temperature: float = 0.0, + use_local_edge: bool = False +) -> str: + """ + Routes UI Telepathic requests purely based on textual interpretation of the screen's XML nodes. + If use_local_edge is manually enabled, routes to localhost:11434. + Otherwise honors the provided URL and model (e.g. OpenRouter). + """ + target_url = url + target_model = model + + if use_local_edge: + logger.info("⚡ [Edge Inference] Routing telepathic request to local Ollama host (0ms latency target).") + from GramAddict.core.config import Config + try: + args = Config().args + target_url = getattr(args, "ai_fallback_url", "http://localhost:11434/api/generate") + target_model = getattr(args, "ai_fallback_model", "llama3.2:1b") + except Exception: + target_url = "http://localhost:11434/api/generate" + target_model = "llama3.2:1b" + + ans = query_llm( + url=target_url, + model=target_model, + prompt=user_prompt, + images_b64=None, + system=system_prompt, + format_json=True + ) + if ans and "response" in ans: + return ans["response"] + return "{}" diff --git a/GramAddict/core/log.py b/GramAddict/core/log.py new file mode 100644 index 0000000..7e8499b --- /dev/null +++ b/GramAddict/core/log.py @@ -0,0 +1,152 @@ +import logging +import os +from logging import LogRecord +from logging.handlers import RotatingFileHandler +from uuid import uuid4 + +from colorama import Fore, Style +from colorama import init as init_colorama + +COLORS = { + "DEBUG": Style.DIM, + "INFO": Fore.WHITE, + "WARNING": Fore.YELLOW, + "ERROR": Fore.RED, + "CRITICAL": Fore.MAGENTA, +} + + +class ColoredFormatter(logging.Formatter): + def __init__(self, *, fmt, datefmt=None): + logging.Formatter.__init__(self, fmt=fmt, datefmt=datefmt) + + def format(self, record): + msg = super().format(record) + levelname = record.levelname + if hasattr(record, "color"): + return f"{record.color}{msg}{Style.RESET_ALL}" + if levelname in COLORS: + return f"{COLORS[levelname]}{msg}{Style.RESET_ALL}" + return msg + + +class LoggerFilterGramAddictOnly(logging.Filter): + def filter(self, record: LogRecord): + return record.name.startswith("GramAddict") + + +def create_log_file_handler(filename): + file_handler = RotatingFileHandler( + filename, + mode="a", + backupCount=10, + maxBytes=15 * 1000000, + encoding="utf-8", + ) + + file_handler.setLevel(logging.DEBUG) + file_handler.setFormatter( + logging.Formatter( + fmt="%(asctime)s %(levelname)8s | %(message)s (%(filename)s:%(lineno)d)", + datefmt=r"[%m/%d %H:%M:%S]", + ) + ) + file_handler.addFilter(LoggerFilterGramAddictOnly()) + return file_handler + + +def configure_logger(debug, username): + global g_session_id + global g_log_file_name + global g_logs_dir + global g_file_handler + global g_log_file_updated + + console_level = logging.DEBUG if debug else logging.INFO + + g_session_id = uuid4() + g_logs_dir = "logs" + if username: + g_log_file_name = f"{username}.log" + g_log_file_updated = True + else: + g_log_file_name = f"{g_session_id}.log" + g_log_file_updated = False + + init_colorama() + + # Root logger + root_logger = logging.getLogger() + root_logger.setLevel(logging.DEBUG) + + # Console logger (limited but colored log) + console_handler = logging.StreamHandler() + console_handler.setLevel(console_level) + console_handler.setFormatter( + ColoredFormatter( + fmt="%(asctime)s %(levelname)8s | %(message)s", datefmt="[%m/%d %H:%M:%S]" + ) + ) + console_handler.addFilter(LoggerFilterGramAddictOnly()) + root_logger.addHandler(console_handler) + + # File logger (full raw log) + if not os.path.exists(g_logs_dir): + os.makedirs(g_logs_dir) + g_file_handler = create_log_file_handler(f"{g_logs_dir}/{g_log_file_name}") + root_logger.addHandler(g_file_handler) + + init_logger = logging.getLogger(__name__) + init_logger.debug(f"Initial log file: {g_logs_dir}/{g_log_file_name}") + + +def get_log_file_config(): + return g_log_file_name, g_logs_dir, g_file_handler, g_session_id + + +def is_log_file_updated(): + return g_log_file_updated + + +def update_log_file_name(username: str): + old_log_file_name, logs_dir, file_handler, _ = get_log_file_config() + old_full_filename = f"{logs_dir}/{old_log_file_name}" + + current_logger = logging.getLogger(__name__) + if not username: + current_logger.error(f"No username found, using log file {old_full_filename}") + return + named_log_file_name = f"{username}.log" + named_full_filename = f"{logs_dir}/{named_log_file_name}" + rollover = bool(os.path.isfile(named_full_filename)) + named_file_handler = create_log_file_handler(named_full_filename) + if rollover: + named_file_handler.doRollover() + + # copy existing runtime logs (uidd4.log) to named log file (username.log) + with open(old_full_filename, "r", encoding="utf-8") as unnamed_file, open( + named_full_filename, "a", encoding="utf-8" + ) as named_file: + for line in unnamed_file: + named_file.write(line) + + root_logger = logging.getLogger() + root_logger.removeHandler(file_handler) + root_logger.addHandler(named_file_handler) + + current_logger = logging.getLogger(__name__) + current_logger.debug(f"Updated log file: {named_full_filename}") + + try: + os.remove(old_full_filename) + except Exception as e: + current_logger.debug( + f"Failed to remove old file: {old_full_filename}. Exception: {e}" + ) + + global g_log_file_name + global g_file_handler + global g_log_file_updated + g_log_file_name = named_log_file_name + g_file_handler = named_file_handler + g_log_file_updated = True diff --git a/GramAddict/core/persistent_list.py b/GramAddict/core/persistent_list.py new file mode 100644 index 0000000..eda45eb --- /dev/null +++ b/GramAddict/core/persistent_list.py @@ -0,0 +1,38 @@ +import json +import os +import logging + +logger = logging.getLogger(__name__) + +class PersistentList(list): + def __init__(self, filename, encoder=None): + super().__init__() + self.filename = filename + self.encoder = encoder + self.load() + + def load(self): + path = f"accounts/{self.filename}.json" + if os.path.exists(path): + try: + with open(path, "r") as f: + data = json.load(f) + self.extend(data) + except Exception as e: + logger.error(f"Failed to load persistent list {self.filename}: {e}") + + def append(self, item): + super().append(item) + self.persist() + + def persist(self, directory=None): + if os.environ.get("PYTEST_CURRENT_TEST"): + return + folder = f"accounts/{directory}" if directory else "accounts" + os.makedirs(folder, exist_ok=True) + path = f"{folder}/{self.filename}.json" + try: + with open(path, "w") as f: + json.dump(list(self), f, cls=self.encoder, indent=4) + except Exception as e: + logger.error(f"Failed to persist {self.filename}: {e}") diff --git a/GramAddict/core/q_nav_graph.py b/GramAddict/core/q_nav_graph.py new file mode 100644 index 0000000..a8e08c5 --- /dev/null +++ b/GramAddict/core/q_nav_graph.py @@ -0,0 +1,264 @@ +import logging +import json +import os +import uuid +import time +import random +from GramAddict.core.compiler_engine import VLMCompilerEngine +from GramAddict.core.qdrant_memory import NavigationMemoryDB + + +logger = logging.getLogger(__name__) + +class Node: + def __init__(self, name: str): + self.name = name + self.transitions = {} # Action (e.g. "tap_search") -> Node + +class QNavGraph: + """ + Project Singularity V7: 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. + """ + def __init__(self, device): + self.device = device + self.nodes = {} + self.current_state = "UNKNOWN" + self.nav_memory = NavigationMemoryDB() + + self.compiler = VLMCompilerEngine(device) + self._load_graph() + + + def _load_graph(self): + """Loads the topological map from Qdrant. Merges with core seeds to guarantee baseline navigation.""" + logger.debug("🌐 [NavGraph] Syncing topological map with Qdrant...") + self.nodes = self.nav_memory.get_all_transitions() + + core_nodes = { + "HomeFeed": {"transitions": {"tap_explore_tab": "ExploreFeed", "tap_profile_tab": "OwnProfile", "tap_message_icon": "MessageInbox"}}, + "ExploreFeed": {"transitions": {"tap_home_tab": "HomeFeed"}}, + "OwnProfile": {"transitions": {"tap_home_tab": "HomeFeed", "tap_following_list": "FollowingList"}}, + "MessageInbox": {"transitions": {"tap_back": "HomeFeed"}}, + "FollowingList": {"transitions": {"tap_back": "OwnProfile"}}, + "UNKNOWN": {"transitions": {"tap_home_tab": "HomeFeed"}} + } + + # Merge core nodes into loaded nodes + for node, data in core_nodes.items(): + if node not in self.nodes: + self.nodes[node] = {"transitions": {}} + for action, target in data["transitions"].items(): + if action not in self.nodes[node]["transitions"]: + self.nodes[node]["transitions"][action] = target + self.nav_memory.store_transition(node, action, target) + + def _save_graph(self): + """Deprecated: Navigation state is now persisted per-transition in Qdrant.""" + pass + + + 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. + """ + logger.info(f"📍 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 + + # 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 + + # 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, zero_engine) + 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.") + self.device.deviceV2.app_start(self.device.app_id, use_monkey=True) + time.sleep(3) + self.current_state = "HomeFeed" + return self.navigate_to(target_state, zero_engine, recovery_attempts=recovery_attempts + 1) + else: + 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) + time.sleep(3) + 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 False + + for action in path: + result = self._execute_transition(action, zero_engine) + + 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) + time.sleep(3) + # 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, zero_engine) + 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 + + def _find_path(self, start: str, end: str): + if start == end: return [] + if start not in self.nodes: return None + + queue = [(start, [])] + visited = set() + + while queue: + current, path = queue.pop(0) + if current == end: + return path + + visited.add(current) + transitions = self.nodes.get(current, {}).get("transitions", {}) + + for action, next_state in transitions.items(): + if next_state not in visited: + queue.append((next_state, path + [action])) + + return None + + def _execute_transition(self, action: str, zero_engine) -> bool: + """ + Executes a transition (e.g. 'tap_explore_tab') using the Telepathic Semantic Engine. + """ + from GramAddict.core.telepathic_engine import TelepathicEngine + engine = TelepathicEngine.get_instance() + + context_xml = self.device.deviceV2.dump_hierarchy() + + # ── Z-Depth Guard / Obstacle Clearance ── + import re + if re.search(r'bottom_sheet_container|dialog_container|dialog_root|bottom_sheet_drag', str(context_xml)): + logger.warning("🛡ī¸ [Z-Depth Guard] Obstacle overlay detected during navigation. Pressing BACK to clear...") + self.device.deviceV2.press("back") + time.sleep(1.5) + # Re-acquire context after clearing obstacle + context_xml = self.device.deviceV2.dump_hierarchy() + + # We phrase the action as an intent for the semantic engine + # e.g. "tap_explore_tab" -> "tap explore tab" + # We add some common synonyms for Instagram to help the vector engine + intent_map = { + # Navigation (Bottom Bar) — aligned with fast-path keys + "tap_home_tab": "tap home tab", + "tap_explore_tab": "tap explore tab", + "tap_profile_tab": "tap profile tab", + "tap_reels_tab": "tap reels tab", + "tap_create_tab": "tap create post tab", + # Post Interaction — aligned with fast-path keys + "tap_like_button": "tap like button", + "tap_comment_button": "tap comment button", + "tap_post_username": "tap post username", + "tap_share_button": "tap share button", + "tap_save_button": "tap save button", + # Grid & Profile + "tap_explore_grid_item": "first image in explore grid", + "tap_story_tray_item": "profile picture avatar story ring", + "tap_follow_button": "tap follow button on profile", + "tap_grid_first_post": "first image post in profile grid", + } + intent_description = intent_map.get(action, action.replace("_", " ")) + + # Use TelepathicEngine to find the most likely node for this intent + # If vector score < 0.82, it will trigger the Vision Cortex Fallback (VLM) + best_node = engine.find_best_node(context_xml, intent_description, min_confidence=0.82, device=self.device) + + if not best_node: + logger.debug(f"_execute_transition: TelepathicEngine found no matching node for '{action}'") + # Check if we are even in the right app + current_app = self.device._get_current_app() + if current_app != self.device.app_id: + logger.warning(f"⚠ī¸ [Context Lost] Currently in '{current_app}', expected '{self.device.app_id}'. Transition '{action}' aborted.") + return "CONTEXT_LOST" + return False + + if best_node.get("skip"): + logger.info(f"⏭ī¸ Skipping physical tap for '{action}' (Semantic Fast-Path indicated state already fulfilled)") + return True + + source_tag = best_node.get("source", "telepathic").replace("_", " ").title() + logger.info(f"QNavGraph executing transition '{action}' via [{source_tag}] (Score: {best_node.get('score', 1.0):.3f})") + + # Execute click + self.device.click(obj=best_node) + time.sleep(random.uniform(1.2, 2.5)) + + # ── Post-Click Verification: Did the screen change? ── + post_click_xml = self.device.deviceV2.dump_hierarchy() + # For navigation, we expect the UI to change or specific markers to appear + # Comparison of XML strings is a good baseline for navigation success + if post_click_xml != context_xml: + engine.confirm_click(intent_description) + return True + else: + logger.warning(f"⚠ī¸ [Nav] Click on '{action}' did not change UI. Learning from failure.") + engine.reject_click(intent_description) + return False + + def _repair_transition(self, action: str): + """ + If a transition fails, the CompilerEngine is invoked to figure out the new UI layout + and write a new rule for `action`. + """ + from GramAddict.core.dojo_engine import DojoEngine + dojo = DojoEngine.get_instance(self.device) + + logger.warning(f"⛩ī¸ [Dojo] Enqueuing auto-labeling job for missing '{action}'.", extra={"color": f"\x1b[36m"}) + context_xml = self.device.deviceV2.dump_hierarchy() + + dojo.submit_snapshot( + heuristic_name=action, + context_xml=context_xml, + intent_prompt=f"Find the button that performs: {action}. Be extremely robust against structural UI changes." + ) diff --git a/GramAddict/core/qdrant_memory.py b/GramAddict/core/qdrant_memory.py new file mode 100644 index 0000000..c2f8ba6 --- /dev/null +++ b/GramAddict/core/qdrant_memory.py @@ -0,0 +1,1097 @@ +import os +import json +import logging +import re +import hashlib +import time +from typing import Optional +from qdrant_client import QdrantClient +from qdrant_client.models import VectorParams, Distance, PointStruct, Filter, FieldCondition, MatchValue +from dotenv import load_dotenv +import requests +import uuid + +logger = logging.getLogger(__name__) + +class QdrantBase: + def __init__(self, collection_name, vector_size=768): + self.collection_name = collection_name + self.client = None + self._vector_size = vector_size + self._consecutive_errors = 0 + self._circuit_open = False + + try: + qdrant_url = os.environ.get("QDRANT_URL", "http://localhost:6344") + self.client = QdrantClient(url=qdrant_url, timeout=10.0) + + if self.client: + if self.client.collection_exists(collection_name): + # Verify dimension match + try: + info = self.client.get_collection(collection_name) + existing_size = info.config.params.vectors.size + if existing_size != vector_size: + logger.warning( + f"Qdrant dimension mismatch for '{collection_name}': " + f"collection has {existing_size}, expected {vector_size}. " + f"Recreating collection..." + ) + self.client.delete_collection(collection_name) + self.client.create_collection( + collection_name=collection_name, + vectors_config=VectorParams(size=vector_size, distance=Distance.COSINE), + ) + logger.info(f"Recreated Qdrant collection '{collection_name}' with dimension {vector_size}.") + except Exception as dim_err: + logger.debug(f"Qdrant dimension check failed (non-fatal): {dim_err}") + else: + self.client.create_collection( + collection_name=collection_name, + vectors_config=VectorParams(size=vector_size, distance=Distance.COSINE), + ) + logger.info(f"Created Qdrant collection '{collection_name}' with dimension {vector_size}.") + except Exception as e: + logger.error(f"Failed to initialize Qdrant memory for '{collection_name}': {e}") + self.client = None + + @property + def is_connected(self) -> bool: + return self.client is not None and not self._circuit_open + + def _handle_error(self, e: Exception, context: str): + self._consecutive_errors += 1 + logger.error(f"❌ [Qdrant] {context}: {e}") + if self._consecutive_errors >= 3: + if not self._circuit_open: + logger.critical(f"🚨 [Qdrant] Circuit breaker triggered! Disabling memory engine for {self.collection_name} due to persistent failures.") + self._circuit_open = True + + def _handle_success(self): + if self._circuit_open: + logger.info(f"đŸŸĸ [Qdrant] Connection recovered for {self.collection_name}. Circuit closed.") + self._consecutive_errors = 0 + self._circuit_open = False + + def _get_embedding(self, text: str) -> Optional[list]: + + from GramAddict.core.config import Config + if not hasattr(self, "_cached_args"): + cfg = Config() + self._cached_args = cfg.args if hasattr(cfg, "args") else None + args = self._cached_args + + # Pull specific embedding config or fallback to defaults + model = getattr(args, "ai_embedding_model", "nomic-embed-text") + url = getattr(args, "ai_embedding_url", "http://localhost:11434/api/embeddings") + + try: + # Generate embeddings + is_cloud = "openrouter.ai" in url.lower() or "openai.com" in url.lower() + + headers = {} + if is_cloud: + key = os.environ.get("OPENROUTER_API_KEY") + if key: + headers["Authorization"] = f"Bearer {key}" + # OpenAI/OpenRouter use 'input' instead of 'prompt' + payload = { + "model": model, + "input": str(text)[:8000] + } + else: + # Local Ollama + payload = { + "model": model, + "prompt": str(text)[:8000] + } + + # Log to prevent user from thinking the bot is hung during model swap in VRAM + if not getattr(self, "_has_logged_embedding", False): + logger.debug(f"🧠 [Ollama] Generating embeddings... (First local hit may take 5-10s to load model into VRAM)") + self._has_logged_embedding = True + + resp = requests.post( + url, + json=payload, + headers=headers, + timeout=12, + ) + if resp.status_code != 200: + logger.debug(f"Embedding API Error {resp.status_code}: {resp.text}") + resp.raise_for_status() + + data = resp.json() + # Handle both Ollama and OpenAI-style embedding responses + if "embedding" in data: + return data["embedding"] + elif "data" in data and len(data["data"]) > 0: + return data["data"][0]["embedding"] + return None + except Exception as e: + logger.debug(f"Failed to generate embedding via {url}: {e}") + return None + + def generate_uuid(self, seed_string: str) -> str: + """ + Generates a valid UUID string required by Qdrant from any raw seed string. + """ + import hashlib + import uuid + return str(uuid.UUID(hex=hashlib.sha256(seed_string.encode('utf-8')).hexdigest()[:32])) + + def upsert_point(self, seed_string: str, payload: dict, vector: list = None, log_success: str = None) -> bool: + """ + Safely upserts a point into Qdrant, handling valid UUID generation. + """ + if not self.is_connected: + return False + + point_id = self.generate_uuid(seed_string) + + # If no vector provided, use a zero-vector if expected, though Qdrant requires vectors unless using empty vectors config. + # Most of our DBs provide vectors, or we just pass a list of 0.0s. + safe_vector = vector if vector is not None else [0.0] * self._vector_size + + try: + self.client.upsert( + collection_name=self.collection_name, + points=[PointStruct(id=point_id, vector=safe_vector, payload=payload)] + ) + + # ABSOLUTE LOGGING: User requirement for full observability + msg = log_success or f"đŸ“Ĩ [Qdrant] Learned new data in {self.collection_name}" + logger.info(f"{msg} (UUID: {point_id[:8]}...)", extra={"color": "\x1b[35m"}) + self._handle_success() + return True + except Exception as e: + self._handle_error(e, f"Failed to upsert point") + return False + + def search_points(self, vector: list, limit: int = 5, score_threshold: float = 0.5) -> list: + """ + Performs vector search with absolute logging. + """ + if not self.is_connected: + return [] + + try: + results = self.client.search( + collection_name=self.collection_name, + query_vector=vector, + limit=limit, + score_threshold=score_threshold + ) + logger.debug(f"🔍 [Qdrant] Search in {self.collection_name} returned {len(results)} matches.") + self._handle_success() + return results + except Exception as e: + self._handle_error(e, f"Search failed") + return [] + + +class HeuristicMemoryDB(QdrantBase): + """ + Project Singularity V7: Stores successfully generated heuristics from the VLMCompilerEngine. + This allows the ZeroLatencyEngine to pull pre-compiled Regex/XPath rules securely. + """ + def __init__(self): + super().__init__(collection_name="gramaddict_heuristics_v7") + + def cache_heuristic(self, intent_description: str, rule: dict): + if not self.is_connected or not rule: return + try: + # We hash the intent description to create a deterministic PointID + doc_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, intent_description)) + vector = self._get_embedding(intent_description) + if not vector: return + + payload = { + "intent": intent_description, + "rule_type": rule.get("rule_type", "regex"), + "target_attribute": rule.get("target_attribute", "text"), + "pattern": rule.get("pattern", ""), + "timestamp": time.time(), + "confidence": 0.9 # Initial confidence + } + + self.upsert_point(intent_description, payload, vector=vector) + + except Exception as e: + logger.error(f"Failed to cache generated heuristic: {e}") + + def fetch_heuristic(self, intent_description: str) -> Optional[dict]: + if not self.is_connected: return None + try: + vector = self._get_embedding(intent_description) + if not vector: return None + + results = self.client.query_points( + collection_name=self.collection_name, + query=vector, + limit=1, + score_threshold=0.98 # Very strict match on intent description + ) + if results and getattr(results, "points", None): + payload = results.points[0].payload + return { + "rule_type": payload.get("rule_type"), + "target_attribute": payload.get("target_attribute"), + "pattern": payload.get("pattern") + } + logger.debug(f"fetch_heuristic: No points found matching {intent_description} above threshold.") + return None + except Exception as e: + logger.debug(f"Failed to fetch heuristic for {intent_description}: {e}") + return None + +class UIMemoryDB(QdrantBase): + """ + Hardened Qdrant-based UI memory for storing and retrieving learned element locations. + + Key design decisions: + - Deterministic IDs: Hash of (intent + structural_signature) → same situation overwrites old entry + - Confidence scoring: Entries gain/lose confidence based on success/failure feedback + - No negative caching: NOT_FOUND results are NEVER stored (prevents memory poisoning) + - Post-validation: Retrieved entries are checked for staleness + """ + + # Minimum confidence score to return a cached result + MIN_CONFIDENCE = 0.3 + # Default confidence for new entries + DEFAULT_CONFIDENCE = 0.7 + # Similarity threshold for vector lookup (Increased to reduce cross-intent confusion) + SIMILARITY_THRESHOLD = 0.95 + + def __init__(self): + super().__init__(collection_name="gramaddict_ui_cache") + + def _create_structural_signature(self, xml_context: str) -> str: + """ + Removes language-specific strings and non-structural attributes from the XML + to create a pure, compact DOM topology string for the embedding model. + """ + # 1. Remove large, high-frequency but non-structural attributes + # We keep class and resource-id as core structural identifiers. + # We remove bounds as they change with resolution/scaling and bloat the string. + attributes_to_remove = [ + 'text', 'content-desc', 'bounds', 'checkable', 'clickable', + 'focusable', 'focused', 'scrollable', 'long-clickable', + 'password', 'selected', 'index', 'package', 'instance' + ] + + sig = xml_context + for attr in attributes_to_remove: + sig = re.sub(rf'{attr}="[^"]*"', '', sig) + + # 2. Cleanup whitespace + sig = re.sub(r'\s+', ' ', sig).strip() + + # 3. Strict truncation for nomic-embed-text context window + return sig[:4000] + + def _deterministic_id(self, intent: str) -> str: + """ + Generate a deterministic point ID from intent. + Same intent = same ID → deduplication via overwrite across all screens. + """ + return hashlib.sha256(intent.encode("utf-8")).hexdigest()[:32] + + def retrieve_memory(self, intent: str, xml_context: str, similarity_threshold: float = None) -> Optional[dict]: + """ + Queries Qdrant for a known resolution representing the given intent. + Returns the cached intent result (e.g. is_ad boolean, or bounding box) if found. + """ + if not self.is_connected: + return None + + # Lowered threshold slightly just in case nomic embedding drifts, but it should be 1.0 for exact intent + if similarity_threshold is None: + similarity_threshold = 0.85 + + # Embed ONLY the intent. We learn elements globally to drastically reduce LLM calls. + text_to_embed = f"Intent: {intent}" + vector = self._get_embedding(text_to_embed) + + if not vector: + return None + + try: + results = self.client.query_points( + collection_name=self.collection_name, + query=vector, + limit=1, + ).points + + if results and results[0].score >= similarity_threshold: + payload = results[0].payload + solution = payload.get("solution") + confidence = payload.get("confidence", self.DEFAULT_CONFIDENCE) + + # ── TTL-based confidence decay ── + # Entries lose ~5% confidence per hour if not re-validated. + # This prevents stale, poisoned entries from persisting forever. + stored_at = payload.get("stored_at", 0) + if stored_at > 0: + import time as _time + age_hours = (_time.time() - stored_at) / 3600 + time_decay = min(age_hours * 0.05, 0.4) # Max 40% decay over 8 hours + effective_confidence = confidence - time_decay + else: + effective_confidence = confidence + + # Filter 1: Never return NOT_FOUND/error entries from cache + if isinstance(solution, dict) and solution.get("type") == "error": + logger.debug(f"Purging poisoned NOT_FOUND entry for '{intent}' from Qdrant Memory.") + self._delete_point(results[0].id) + return None + + # Filter 2: Skip low-confidence entries (using effective confidence with TTL decay) + if effective_confidence < self.MIN_CONFIDENCE: + logger.debug(f"Skipping expired/low-confidence ({effective_confidence:.2f}, raw: {confidence:.2f}) entry for '{intent}'.") + # If it's really old and decayed, just delete it + if effective_confidence < 0.1: + self._delete_point(results[0].id) + return None + + logger.debug(f"Resolved intent '{intent}' from Qdrant Memory! (Score: {results[0].score:.3f}, Confidence: {effective_confidence:.2f})") + return solution + else: + score = results[0].score if results else 0.0 + logger.debug(f"No high-confidence match found in Qdrant (Best score: {score:.3f})") + return None + except Exception as e: + logger.debug(f"Qdrant retrieval error: {e}") + return None + + def store_memory(self, intent: str, xml_context: str, solution: dict): + """ + Saves a successful resolution for an intent into the Qdrant DB. + """ + if not self.is_connected: + return + + # GUARD: Never store negative/error results + if isinstance(solution, dict): + if solution.get("type") == "error" or solution.get("value") == "NOT_FOUND": + logger.debug(f"Refusing to store NOT_FOUND result for '{intent}'. This prevents memory poisoning.") + return + + text_to_embed = f"Intent: {intent}" + vector = self._get_embedding(text_to_embed) + + if not vector: + return + + try: + # Deterministic ID: same intent = overwrite, not duplicate + point_id = self._deterministic_id(intent) + + self.client.upsert( + collection_name=self.collection_name, + points=[ + PointStruct( + id=point_id, + vector=vector, + payload={ + "intent": intent, + "solution": solution, + "confidence": self.DEFAULT_CONFIDENCE, + "stored_at": time.time(), + } + ) + ], + wait=True + ) + logger.info(f"Learned pattern for '{intent}' and saved to Qdrant Memory (ID: {point_id[:8]}...).") + except Exception as e: + logger.debug(f"Qdrant storage error: {e}") + + def boost_confidence(self, *args, **kwargs): + """Called when an element from memory was successfully used.""" + intent = kwargs.get("intent") or (args[0] if args else None) + amount = kwargs.get("amount", 0.15) + if not intent: return + try: amount = float(amount) + except (ValueError, TypeError): amount = 0.15 + self._adjust_confidence(intent, amount) + + def decay_confidence(self, *args, **kwargs): + """Called when an element from memory failed validation (not found on screen).""" + intent = kwargs.get("intent") or (args[0] if args else None) + amount = kwargs.get("amount", 0.50) # Harder punishment: 2 failures = near-dead + if not intent: return + try: amount = float(amount) + except (ValueError, TypeError): amount = 0.50 + self._adjust_confidence(intent, -amount) + + def _adjust_confidence(self, intent: str, delta: float): + """Adjusts the confidence score of a cached entry using only its intent ID.""" + if not self.is_connected: + return + + point_id = self._deterministic_id(intent) + + try: + # Fetch current point + points = self.client.retrieve( + collection_name=self.collection_name, + ids=[point_id], + with_payload=True, + with_vectors=False, + ) + + if not points: + return + + current = points[0].payload + new_confidence = max(0.0, min(1.0, current.get("confidence", self.DEFAULT_CONFIDENCE) + delta)) + + # If confidence dropped below threshold, delete the entry entirely + if new_confidence < 0.1: + logger.info(f"Confidence for '{intent}' dropped to {new_confidence:.2f}. Removing stale entry.") + self._delete_point(point_id) + return + + # Update payload with new confidence + self.client.set_payload( + collection_name=self.collection_name, + payload={"confidence": new_confidence}, + points=[point_id], + ) + logger.debug(f"Confidence for '{intent}' adjusted to {new_confidence:.2f} (delta: {delta:+.2f}).") + except Exception as e: + logger.debug(f"Confidence adjustment error: {e}") + + def _delete_point(self, point_id: str): + """Deletes a single point from Qdrant by ID.""" + try: + from qdrant_client.models import PointIdsList + self.client.delete( + collection_name=self.collection_name, + points_selector=PointIdsList(points=[point_id]), + ) + except Exception as e: + logger.debug(f"Failed to delete point {point_id}: {e}") + + def purge_stale_entries(self): + """Startup hygiene: remove low-confidence and expired entries.""" + if not self.is_connected: + return + try: + points, _ = self.client.scroll( + collection_name=self.collection_name, + limit=500, + with_payload=True, + ) + purged = 0 + import time as _time + now = _time.time() + for pt in points: + payload = pt.payload or {} + confidence = payload.get("confidence", self.DEFAULT_CONFIDENCE) + stored_at = payload.get("stored_at", 0) + age_hours = (now - stored_at) / 3600 if stored_at > 0 else 0 + + # Purge if: confidence dropped below 0.5, or older than 24 hours + if confidence < 0.5 or age_hours > 24: + self._delete_point(pt.id) + purged += 1 + if purged: + logger.info(f"🧹 Startup purge: Removed {purged} stale/expired Qdrant entries.") + except Exception as e: + logger.debug(f"Startup purge error (non-fatal): {e}") + + +class CommentMemoryDB(QdrantBase): + def __init__(self): + super().__init__(collection_name="gramaddict_learned_comments") + + def store_comment(self, text: str, vibe: str, author: str = "unknown"): + """Saves a high-quality learned comment.""" + if not self.is_connected: + return + + vector = self._get_embedding(text) + if not vector: + return + + self.upsert_point( + seed_string=str(time.time()), + vector=vector, + payload={ + "text": text, + "vibe": vibe, + "author": author + }, + log_success=f"🧠 [CommentMemory] Learned and stored comment: '{text[:30]}...' (Vibe: {vibe})" + ) + + def get_relevant_comments(self, context_text: str, limit: int = 3) -> list[str]: + """Retrieves similar comments from memory to use as examples.""" + if not self.is_connected: + return [] + + vector = self._get_embedding(context_text) + if not vector: + return [] + + try: + results = self.client.query_points( + collection_name=self.collection_name, + query=vector, + limit=limit, + ).points + return [hit.payload.get("text") for hit in results if hit.score > 0.7] + except Exception as e: + logger.debug(f"Comment retrieval error: {e}") + return [] + +class ContentMemoryDB(QdrantBase): + def __init__(self): + super().__init__(collection_name="gramaddict_content_memory") + + def store_evaluation(self, description: str, classification: str, reason: str): + """Saves an AI-evaluated description to memory.""" + if not self.is_connected or not description: + return + + vector = self._get_embedding(description) + if not vector: + return + + self.upsert_point( + seed_string=description, + vector=vector, + payload={ + "description": description, + "classification": classification, + "reason": reason, + "stored_at": time.time(), + }, + log_success=f"🧠 [ContentMemory] Stored evaluation in memory: {classification} ({reason})" + ) + + def get_cached_evaluation(self, description: str, similarity_threshold: float = 0.95) -> Optional[dict]: + """Queries for a nearly identical past post to act as a cache.""" + if not self.is_connected or not description: + return None + + vector = self._get_embedding(description) + if not vector: + return None + + try: + results = self.client.query_points( + collection_name=self.collection_name, + query=vector, + limit=1, + ).points + + if results and results[0].score >= similarity_threshold: + payload = results[0].payload + logger.info(f"Qdrant Cache Hit! Similar post found (score: {results[0].score:.3f}). Classification: {payload.get('classification')}") + return payload + return None + except Exception as e: + logger.debug(f"Content memory retrieval error: {e}") + return None + + def get_similar_examples(self, description: str, limit: int = 3) -> list[dict]: + """Retrieves similar past post evaluations to use in RAG few-shot prompting.""" + if not self.is_connected or not description: + return [] + + vector = self._get_embedding(description) + if not vector: + return [] + + try: + results = self.client.query_points( + collection_name=self.collection_name, + query=vector, + limit=limit, + ).points + + examples = [] + for hit in results: + payload = hit.payload + examples.append({ + "description": payload.get("description", "")[:200], + "classification": payload.get("classification"), + "reason": payload.get("reason"), + }) + return examples + except Exception as e: + logger.debug(f"Content RAG retrieval error: {e}") + return [] + + + +class NavigationMemoryDB(QdrantBase): + """ + Project Singularity V8: Topological Navigation Persistence. + Stores learned paths and transitions discovered during autonomous exploration. + This eliminates "Context Stagnation" by sharing learned navigation across the fleet. + """ + def __init__(self): + # We use a smaller vector size for navigation tags or just zero-vectors for KV storage + super().__init__(collection_name="gramaddict_nav_graph_v8", vector_size=128) + + def store_transition(self, from_state: str, action: str, to_state: str): + key = f"{from_state}_{action}" + payload = { + "from": from_state, + "action": action, + "to": to_state, + "timestamp": time.time() + } + self.upsert_point(key, payload, log_success=f"🧠 [NavBrain] Learned transition: {from_state} --({action})--> {to_state}") + + def get_all_transitions(self) -> dict: + """Retrieves the full topological map from Qdrant.""" + if not self.is_connected: return {} + try: + resp = self.client.scroll(collection_name=self.collection_name, limit=100) + points = resp[0] + nodes = {} + for p in points: + data = p.payload + f, a, t = data["from"], data["action"], data["to"] + if f not in nodes: nodes[f] = {"transitions": {}} + nodes[f]["transitions"][a] = t + return nodes + except Exception as e: + logger.error(f"Failed to fetch nav graph from Qdrant: {e}") + return {} + +class PersonaMemoryDB(QdrantBase): + + def __init__(self): + super().__init__(collection_name="gramaddict_persona_memory") + + def store_persona_insight(self, category: str, insight: str): + """Saves a learned insight about the logged-in user's brand persona.""" + if not self.is_connected or not insight: + return + + vector = self._get_embedding(insight) + if not vector: + return + + self.upsert_point( + seed_string=category + insight, + vector=vector, + payload={ + "category": category, + "insight": insight, + "stored_at": time.time(), + }, + log_success=f"🧠 [PersonaMemory] Learned Brand Persona ({category}): {insight[:50]}..." + ) + + def get_persona_context(self, category: str = None, limit: int = 5) -> str: + """Retrieves and formats learned persona guidelines.""" + if not self.is_connected: + return "" + + try: + query_filter = None + if category: + query_filter = Filter( + must=[ + FieldCondition( + key="category", + match=MatchValue(value=category) + ) + ] + ) + + # Use scroll to just fetch the most recent or all relevant insights since we don't have a semantic query to match against. + # We just want the general guidelines for the prompt. + points, _ = self.client.scroll( + collection_name=self.collection_name, + scroll_filter=query_filter, + limit=limit, + with_payload=True, + ) + + if not points: + return "" + + contexts = [] + for pt in points: + payload = pt.payload + cat = payload.get("category", "General") + ins = payload.get("insight", "") + contexts.append(f"[{cat}] {ins}") + + return "\n".join(contexts) + except Exception as e: + logger.debug(f"Persona retrieval error: {e}") + return "" + +class BannedPathsDB: + """ + Negative feedback memory: stores which specific elements FAILED + for which goals. Simple dict-based storage (no vectors needed). + + Key insight: This is NOT a vector similarity problem. The relationship + is exact: "goal X + element Y = failure". So we use a simple hash map + stored in Qdrant as payload-only points. + """ + + # Max age for banned entries (7 days) — Instagram updates can change layouts + MAX_AGE_SECONDS = 7 * 24 * 3600 + + def __init__(self): + self._banned = {} # {goal_hash: set(element_ids)} + self._client = None + self._collection = "gramaddict_banned_paths" + + try: + qdrant_url = os.environ.get("QDRANT_URL", "http://localhost:6344") + self._client = QdrantClient(url=qdrant_url, timeout=5.0) + + # Create collection with a dummy 1-dim vector (Qdrant requires vectors) + if self._client and not self._client.collection_exists(self._collection): + self._client.create_collection( + collection_name=self._collection, + vectors_config=VectorParams(size=4, distance=Distance.COSINE), + ) + + # Load all banned entries into memory at startup + self._load_all() + except Exception as e: + logger.debug(f"BannedPaths init (non-fatal): {e}") + + def _goal_hash(self, goal: str) -> str: + return hashlib.sha256(goal.lower().strip().encode("utf-8")).hexdigest()[:16] + + def _point_id(self, goal: str, element_id: str) -> str: + combined = f"{goal.lower().strip()}||{element_id}" + import uuid + return str(uuid.UUID(hex=hashlib.sha256(combined.encode("utf-8")).hexdigest()[:32])) + + def _load_all(self): + """Load all banned paths from Qdrant into memory at startup.""" + if not self._client: + return + try: + points, _ = self._client.scroll( + collection_name=self._collection, + limit=500, + with_payload=True, + ) + now = time.time() + expired = [] + for pt in points: + payload = pt.payload or {} + # Expire old entries + if now - payload.get("banned_at", 0) > self.MAX_AGE_SECONDS: + expired.append(pt.id) + continue + gh = payload.get("goal_hash", "") + eid = payload.get("element_id", "") + if gh and eid: + if gh not in self._banned: + self._banned[gh] = set() + self._banned[gh].add(eid) + + # Clean expired + if expired: + from qdrant_client.models import PointIdsList + self._client.delete( + collection_name=self._collection, + points_selector=PointIdsList(points=expired), + ) + logger.debug(f"BannedPaths: Expired {len(expired)} old entries.") + + total = sum(len(v) for v in self._banned.values()) + if total > 0: + logger.info(f"BannedPaths: Loaded {total} banned element-goal pairs.") + except Exception as e: + logger.debug(f"BannedPaths load error (non-fatal): {e}") + + def ban(self, goal: str, element_id: str, reason: str = ""): + """Ban a specific element for a specific goal.""" + if not element_id: + return + + gh = self._goal_hash(goal) + if gh not in self._banned: + self._banned[gh] = set() + self._banned[gh].add(element_id) + + logger.warning(f"BannedPaths: Banned '{element_id}' for goal '{goal[:60]}'. Reason: {reason}") + + # Persist to Qdrant + if self._client: + try: + pid = self._point_id(goal, element_id) + self._client.upsert( + collection_name=self._collection, + points=[ + PointStruct( + id=pid, + vector=[0.0, 0.0, 0.0, 0.0], # dummy vector + payload={ + "goal": goal[:200], + "goal_hash": gh, + "element_id": element_id, + "reason": reason[:200], + "banned_at": time.time(), + } + ) + ] + ) + except Exception as e: + logger.debug(f"BannedPaths persist error: {e}") + + def is_banned(self, goal: str, element_id: str) -> bool: + """Check if a specific element is banned for a specific goal.""" + if not element_id: + return False + gh = self._goal_hash(goal) + return element_id in self._banned.get(gh, set()) + + def get_banned_ids(self, goal: str) -> set: + """Get all banned element IDs for a specific goal.""" + gh = self._goal_hash(goal) + return self._banned.get(gh, set()).copy() + +class DMMemoryDB(QdrantBase): + def __init__(self): + super().__init__(collection_name="gramaddict_dm_memory") + + def log_sent_dm(self, target_username: str, message: str, biography: str, recent_descriptions: list): + if not self.is_connected: + return + + vector = self._get_embedding(message) + if not vector: + return + + self.upsert_point( + seed_string=f"{target_username}_{message}_{time.time()}", + vector=vector, + payload={ + "target_username": target_username, + "message": message, + "biography": biography, + "recent_descriptions": recent_descriptions, + "status": "pending", + "score": 0.0, + "timestamp": time.time() + }, + log_success="🧠 [Growth Brain] Logged sent DM to memory for future response tracking." + ) + + def get_pending_dms(self, limit=10): + if not self.is_connected: + return [] + try: + points = self.client.query_points( + collection_name=self.collection_name, + query=self._get_embedding(""), + query_filter=Filter( + must=[ + FieldCondition( + key="status", + match=MatchValue(value="pending") + ) + ] + ), + limit=limit + ).points + + return [p.payload for p in points] + except Exception as e: + logger.debug(f"[DMMemory] get_pending_dms failed: {e}") + return [] + + def update_dm_score(self, point_id: str, new_score: float, status: str = "evaluated"): + if not self.is_connected: + return + try: + self.client.set_payload( + collection_name=self.collection_name, + payload={"status": status, "score": new_score}, + points=[point_id] + ) + logger.info(f"🧠 [Growth Brain] Updated DM Resonance Score: {new_score:.1f}") + except Exception as e: + logger.debug(f"Failed to update DM score: {e}") + + def get_best_performing_dms(self, limit=3): + if not self.is_connected: + return [] + try: + results = self.client.scroll( + collection_name=self.collection_name, + scroll_filter=Filter( + must=[ + FieldCondition( + key="status", + match=MatchValue(value="evaluated") + ) + ] + ), + limit=100, + with_payload=True + )[0] + + dms = [r.payload["message"] for r in results if r.payload.get("score", 0.0) >= 0.8] + dms = list(set(dms)) + return dms[:limit] + except Exception as e: + logger.debug(f"Failed to fetch best DMs: {e}") + return [] + +class ParasocialCRMDB(QdrantBase): + collection_name = "ig_parasocial_crm" + + def __init__(self): + super().__init__(self.collection_name) + + def get_relationship_stage(self, username: str) -> dict: + """ + Returns the current CRM stage and last interaction timestamp. + Stages: 0=Awareness, 1=Curiosity, 2=Rapport, 3=Conversion + + Uses exact-match filter (not embedding) — usernames are deterministic keys, + not semantic content. This is ~100x faster than embedding search. + """ + if not self.is_connected: + return {"stage": 0, "last_interaction": 0.0, "interactions": []} + + try: + points, _ = self.client.scroll( + collection_name=self.collection_name, + scroll_filter=Filter( + must=[ + FieldCondition( + key="username", + match=MatchValue(value=username) + ) + ] + ), + limit=1, + with_payload=True, + ) + + if points: + return points[0].payload + except Exception as e: + logger.debug(f"[ParasocialCRM] query failed: {e}") + + return {"stage": 0, "last_interaction": 0.0, "interactions": []} + + def log_interaction(self, username: str, intent_type: str, new_stage: int = None): + """ + Logs an interaction (e.g. 'story_view', 'deep_like', 'comment_reply'). + Upgrades stage automatically if new_stage is provided. + """ + if not self.is_connected: + return + + current = self.get_relationship_stage(username) + stage = new_stage if new_stage is not None else current["stage"] + + interactions = current.get("interactions", []) + import time + now = time.time() + interactions.append({ + "type": intent_type, + "timestamp": now + }) + + payload = { + "username": username, + "stage": stage, + "last_interaction": now, + "interactions": interactions[-10:] # keep last 10 + } + + vector = self._get_embedding(f"User: {username}") + if vector: + self.upsert_point( + seed_string=f"User_{username}", + vector=vector, + payload=payload, + log_success=f"🧠 [ParasocialCRM] Updated @{username} into Qdrant. Stage {stage} ({intent_type})" + ) + + def log_generated_comment(self, username: str, comment_text: str): + """Phase 10: RAG memory point for specific users.""" + if not self.is_connected: + return + + current = self.get_relationship_stage(username) + interactions = current.get("interactions", []) + + interactions.append({ + "type": "comment_sent", + "text": comment_text, + "timestamp": time.time() + }) + + payload = { + "username": username, + "stage": current["stage"], + "last_interaction": time.time(), + "interactions": interactions[-20:], # Keep last 20 interactions + "bio": current.get("bio", "") + } + + vector = self._get_embedding(f"User: {username}") + if vector: + self.upsert_point( + seed_string=f"User_{username}", + vector=vector, + payload=payload, + log_success=f"🧠 [ParasocialCRM] Logged generated comment for @{username} into Qdrant." + ) + + def log_profile_context(self, username: str, bio: str): + """Phase 10: Store parsed user bio for hyper-personalization.""" + if not self.is_connected or not username: + return + + current = self.get_relationship_stage(username) + # Avoid unnecessary DB writes if the bio hasn't fundamentally changed + if current.get("bio") == bio: + return + + payload = { + "username": username, + "stage": current["stage"], + "last_interaction": current["last_interaction"], + "interactions": current.get("interactions", []), + "bio": bio + } + + vector = self._get_embedding(f"User: {username}") + if vector: + self.upsert_point( + seed_string=f"User_{username}", + vector=vector, + payload=payload, + log_success=f"🧠 [ParasocialCRM] Learned profile context for @{username} (Bio: {bio[:30]}...)" + ) + + def get_conversation_context(self, username: str) -> str: + """Phase 10: Constructs semantic context from prior comments with this user.""" + current = self.get_relationship_stage(username) + interactions = current.get("interactions", []) + + context_parts = [] + if current.get("bio"): + context_parts.append(f"User Bio: {current['bio']}") + + comments = [i["text"] for i in interactions if i.get("type") == "comment_sent" and "text" in i] + if comments: + context_parts.append("Previous Comments: " + " | ".join(comments)) + + return "\n".join(context_parts) + diff --git a/GramAddict/core/resonance_engine.py b/GramAddict/core/resonance_engine.py new file mode 100644 index 0000000..68ddfce --- /dev/null +++ b/GramAddict/core/resonance_engine.py @@ -0,0 +1,260 @@ +import logging +import math +from typing import Optional +from colorama import Fore + +from GramAddict.core.qdrant_memory import ContentMemoryDB, PersonaMemoryDB, ParasocialCRMDB, CommentMemoryDB +from GramAddict.core.llm_provider import query_llm + +logger = logging.getLogger(__name__) + +class ResonanceEngine: + """ + The Aesthetic Oracle — Real AI Content Evaluation. + + Calculates semantic alignment (Resonance Score) between the bot's + configured persona interests and target content using vector embeddings. + + This drives ALL downstream decisions: + - Like probability (score >= 0.35) + - Comment probability (score >= 0.8) + - Rabbit Hole / profile visit (score >= 0.9) + - Dopamine spike intensity + - Darwin dwell time modulation + """ + def __init__(self, my_username: str, persona_interests: list[str] = None, crm: ParasocialCRMDB = None): + self.my_username = my_username + self.content_memory = ContentMemoryDB() + self.persona_memory = PersonaMemoryDB() + self.crm = crm + self.threshold = 0.5 + + + # The persona vector is the mathematical identity of what content we care about. + # It's generated from config's persona_interests and cached for the entire session. + self._persona_vector: Optional[list] = None + self._persona_interests = persona_interests or [] + + # Bootstrap persona on init + if self._persona_interests: + self._bootstrap_persona() + + def _bootstrap_persona(self): + """ + Generates and caches the persona embedding from configured interests. + Called once on init. The persona vector is what every post is compared against. + """ + persona_text = f"Content about: {', '.join(self._persona_interests)}" + self._persona_vector = self.content_memory._get_embedding(persona_text) + + if self._persona_vector: + # Store in PersonaMemoryDB for persistence across sessions + self.persona_memory.store_persona_insight( + "interests", + f"Core niche interests: {', '.join(self._persona_interests)}" + ) + logger.info( + f"✨ [Resonance Oracle] Persona vector initialized from config: {self._persona_interests}", + extra={"color": f"{Fore.MAGENTA}"} + ) + else: + logger.warning("✨ [Resonance Oracle] Could not generate persona embedding. Falling back to neutral scoring.") + + def _cosine_similarity(self, v1: list, v2: list) -> float: + """Pure python cosine similarity — no numpy dependency.""" + if not v1 or not v2 or len(v1) != len(v2): + return 0.0 + dot = sum(a * b for a, b in zip(v1, v2)) + mag1 = math.sqrt(sum(a * a for a in v1)) + mag2 = math.sqrt(sum(b * b for b in v2)) + if mag1 == 0 or mag2 == 0: + return 0.0 + return dot / (mag1 * mag2) + + def calculate_resonance(self, post_content: dict) -> float: + """ + Real AI resonance score based on embedding cosine similarity. + """ + username = post_content.get("username", "Unknown") + description = post_content.get("description", "") + + logger.info(f"✨ [Resonance Oracle] Evaluating content from @{username}...", extra={"color": f"{Fore.MAGENTA}"}) + + # Build a rich text representation of the post + + description = post_content.get("description", "") + caption = post_content.get("caption", "") + username = post_content.get("username", "") + + content_text = " ".join(filter(None, [description, caption])).strip() + + if not content_text or len(content_text) < 5: + logger.debug("✨ [Resonance] Post has no extractable content. Neutral score.") + return 0.5 # Neutral — can't evaluate what we can't see + + # 1. Check ContentMemoryDB cache — have we seen nearly identical content? + cached = self.content_memory.get_cached_evaluation(content_text) + if cached: + score = self._classification_to_score(cached.get("classification", "medium")) + logger.info( + f"✨ [Resonance Cache Hit] '{content_text[:40]}...' → {score*100:.1f}%", + extra={"color": f"{Fore.MAGENTA}"} + ) + return score + + # 2. No persona vector? Can't do real evaluation. + if not self._persona_vector: + logger.debug("✨ [Resonance] No persona vector. Configure persona_interests in config.yml.") + return 0.5 + + # 3. Generate embedding of the post content + post_vector = self.content_memory._get_embedding(content_text) + if not post_vector: + return 0.5 + + # 4. Cosine similarity against persona = resonance score + raw_score = self._cosine_similarity(post_vector, self._persona_vector) + + # Normalize: text-embedding-3-small cosine similarity for text embeddings typically ranges 0.15 (completely distinct) to 0.55 (very matched, but not literal identical copies) + # Map this to a more useful 0.0-1.0 range + score = max(0.0, min(1.0, (raw_score - 0.15) / 0.30)) + + # 5. Store evaluation in ContentMemoryDB for future cache hits + classification = "high" if score > 0.7 else "medium" if score > 0.4 else "low" + self.content_memory.store_evaluation( + content_text[:500], # Cap length for storage + classification, + f"Resonance: {score:.3f} (raw cosine: {raw_score:.3f})" + ) + + # 6. Feed the Parasocial CRM + if self.crm and username: + intent = f"aesthetic_evaluation_{classification}" + # Stage mapping: high resonance -> stage 1 (Curiosity) + new_stage = 1 if classification == "high" else None + self.crm.log_interaction(username, intent, new_stage=new_stage) + + logger.info( + f"✨ [Resonance Oracle] '{content_text[:50]}...' → {score*100:.1f}% ({classification})", + extra={"color": f"{Fore.MAGENTA}"} + ) + return 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 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 + + def extract_and_learn_comments(self, xml_hierarchy: str, configs, author: str = "unknown"): + """ + Phase 10: RAG Comment Learning Implementation + Extracts comments from the UI hierarchy, filters them using the assigned VLM against + configured blacklists and vibes, and stores them in Qdrant CommentMemoryDB. + """ + if not configs or not getattr(configs.args, "ai_learn_comments", False): + return + + vibe = getattr(configs.args, "ai_vibe", "") + blacklist = getattr(configs.args, "ai_blacklist_topics", "") + if not vibe: + return # No vibe to learn + + logger.info(f"🧠 [Comment Learning] Extracting comments matching vibe: '{vibe}'...", extra={"color": f"{Fore.CYAN}"}) + + # 1. Very basic semantic extraction (grab text nodes that look like comments) + raw_comments = [] + + try: + import xml.etree.ElementTree as ET + root = ET.fromstring(xml_hierarchy) + for node in root.iter('node'): + text = node.get("text", "") + content_desc = node.get("content-desc", "") + val = text if text else content_desc + if val and len(val) > 15: + if val.lower() not in ["reply", "like", "view replies", "see translation", "hide replies"]: + raw_comments.append(val) + except Exception as e: + logger.error(f"🧠 [Comment Learning] Failed to parse XML: {e}") + return + + if not raw_comments: + logger.debug("🧠 [Comment Learning] No legible comments found in UI.") + return + + # Deduplicate and limit + raw_comments = list(set(raw_comments))[:10] + logger.debug(f"🧠 [Comment Learning] Scraped {len(raw_comments)} potential comment nodes. Passing to Condenser...") + + logger.debug(f"🧠 [Comment Learning] Raw texts passed to Condenser:\n{chr(10).join(raw_comments)}") + + # 2. Filter via VLM Condenser + prompt = ( + f"Filter these Instagram comments. Keep ONLY real comments that generally match this vibe: '{vibe}'.\n" + f"Remove comments about: {blacklist}\n" + f"Remove UI junk text (buttons, labels, timestamps).\n\n" + f"Comments:\n{chr(10).join(raw_comments)}\n\n" + "Output a JSON array of matching comment strings. If none match, output []." + ) + + model = getattr(configs.args, "ai_condenser_model", "google/gemini-2.5-flash-lite-preview") + url = getattr(configs.args, "ai_condenser_url", "https://openrouter.ai/api/v1/chat/completions") + + try: + import json + # Fix: kwargs match query_llm signature EXACTLY to evade TypeError + response_dict = query_llm(url=url, model=model, prompt=prompt, format_json=True) + if not response_dict or "response" not in response_dict: + return + + response_text = response_dict["response"] + + # Parse json gracefully + if type(response_text) is str: + clean_json = response_text.strip() + if clean_json.startswith("```json"): + clean_json = clean_json[7:] + if clean_json.endswith("```"): + clean_json = clean_json[:-3] + try: + learned_comments = json.loads(clean_json.strip()) + except json.JSONDecodeError: + logger.error("🧠 [Comment Learning] LLM returned invalid JSON.") + return + else: + # In case expect_json already returned a parsed list somehow, though extract_json returns str + learned_comments = response_text + + if not isinstance(learned_comments, list): + logger.error("🧠 [Comment Learning] Condenser failed to return a JSON list.") + return + + if not learned_comments: + logger.info("🧠 [Comment Learning] Condenser rejected all scraped comments (did not align with vibe or hit blacklist).", extra={"color": f"{Fore.YELLOW}"}) + return + + logger.info(f"🧠 [Comment Learning] Condenser approved {len(learned_comments)} comments. Persisting to Qdrant...", extra={"color": f"{Fore.GREEN}"}) + + # 3. Store the passing comments into Qdrant + comment_db = CommentMemoryDB() + stored = 0 + for c in learned_comments: + if isinstance(c, str) and len(c) > 5: + logger.debug(f" 👉 Storing: '{c}'") + comment_db.store_comment(text=c, vibe=vibe, author=author) + stored += 1 + + if stored > 0: + logger.info(f"✅ [Comment Vector Sync] Successfully embedded {stored} high-vibe comments into memory.", extra={"color": f"{Fore.GREEN}"}) + + except Exception as e: + logger.error(f"🧠 [Comment Learning] Condenser failed: {e}") diff --git a/GramAddict/core/sensors/honeypot_radome.py b/GramAddict/core/sensors/honeypot_radome.py new file mode 100644 index 0000000..f04eb9d --- /dev/null +++ b/GramAddict/core/sensors/honeypot_radome.py @@ -0,0 +1,93 @@ +import logging +import re +import xml.etree.ElementTree as ET + +logger = logging.getLogger(__name__) + +class HoneypotRadome: + """ + Project Dojo: The Anti-Test Sensor. + Filters the Android XML Hierarchy to remove "invisible traps" and honeypots + that Instagram uses to detect deterministic bots (e.g., 1x1 pixel buttons, + off-screen elements with clickable=True). + """ + + def __init__(self, display_width=1080, display_height=2400): + self.display_width = display_width + self.display_height = display_height + self.bounds_pattern = re.compile(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]') + + def sanitize_xml(self, xml_string: str) -> str: + """ + Parses raw UI Automator XML and strips out fake or impossible nodes. + Returns the sanitized XML string. + """ + try: + # Android XML dumps often have multiple root nodes or formatting issues, + # let's try reading it safely. + # Handle potential encoding issues from dump_hierarchy + clean_xml = xml_string.replace(' ', '').replace(' ', '') + + root = ET.fromstring(clean_xml) + removed_count = self._filter_node(root) + + if removed_count > 0: + logger.info(f"🛡ī¸ [Honeypot Radome] Stripped {removed_count} phantom nodes from view.", extra={"color": "\x1b[33m"}) + + # Convert back to string + return ET.tostring(root, encoding='unicode') + except Exception as e: + logger.warning(f"🛡ī¸ [Honeypot Radome] XML Parse failed, returning raw. Err: {e}") + return xml_string + + def _filter_node(self, node: ET.Element) -> int: + removed = 0 + children_to_remove = [] + + for child in node: + if self._is_honeypot(child): + children_to_remove.append(child) + removed += 1 + else: + removed += self._filter_node(child) + + for child in children_to_remove: + node.remove(child) + + return removed + + def _is_honeypot(self, node: ET.Element) -> bool: + """ + Detects if a node is physically impossible to be clicked by a human. + """ + bounds = node.get("bounds") + if not bounds: + return False + + match = self.bounds_pattern.match(bounds) + if not match: + return False + + x1, y1, x2, y2 = map(int, match.groups()) + width = x2 - x1 + height = y2 - y1 + + is_clickable = node.get("clickable", "false").lower() == "true" + + # Rule 1: The Zero-Point Trap (Element is exactly on 0,0 with no dimensions) + if x1 == 0 and y1 == 0 and x2 == 0 and y2 == 0: + return True + + # Rule 2: The Micro-Pixel Trap (Bot detectors often use 1x1 or 2x2 clickable overlay pixels) + if is_clickable and width <= 2 and height <= 2: + return True + + # Rule 3: The Off-Screen Trap (Buttons rendered wildly out of bounds to bait mindless loops) + if x1 >= self.display_width or y1 >= self.display_height: + return True + + # Rule 4: The Negative Coordinate Trap + if x2 <= 0 or y2 <= 0: + return True + + return False diff --git a/GramAddict/core/session_state.py b/GramAddict/core/session_state.py new file mode 100644 index 0000000..c88d54b --- /dev/null +++ b/GramAddict/core/session_state.py @@ -0,0 +1,321 @@ +import logging +import uuid +from datetime import datetime, timedelta +from enum import Enum, auto +from json import JSONEncoder + +from GramAddict.core.utils import get_value + +logger = logging.getLogger(__name__) + + +class SessionState: + id = None + args = {} + my_username = None + my_posts_count = None + my_followers_count = None + my_following_count = None + totalInteractions = {} + successfulInteractions = {} + totalFollowed = {} + totalLikes = 0 + totalComments = 0 + totalPm = 0 + totalWatched = 0 + totalUnfollowed = 0 + removedMassFollowers = [] + totalScraped = 0 + totalCrashes = 0 + startTime = None + finishTime = None + + def __init__(self, configs): + self.id = str(uuid.uuid4()) + self.args = configs.args + self.my_username = None + self.my_posts_count = None + self.my_followers_count = None + self.my_following_count = None + self.totalInteractions = {} + self.successfulInteractions = {} + self.totalFollowed = {} + self.totalLikes = 0 + self.totalComments = 0 + self.totalPm = 0 + self.totalWatched = 0 + self.totalUnfollowed = 0 + self.removedMassFollowers = [] + self.totalScraped = {} + self.totalCrashes = 0 + self.startTime = datetime.now() + self.finishTime = None + + def add_interaction(self, source, succeed, followed, scraped): + if self.totalInteractions.get(source) is None: + self.totalInteractions[source] = 1 + else: + self.totalInteractions[source] += 1 + + if self.successfulInteractions.get(source) is None: + self.successfulInteractions[source] = 1 if succeed else 0 + else: + if succeed: + self.successfulInteractions[source] += 1 + + if self.totalFollowed.get(source) is None: + self.totalFollowed[source] = 1 if followed else 0 + else: + if followed: + self.totalFollowed[source] += 1 + if self.totalScraped.get(source) is None: + self.totalScraped[source] = 1 if scraped else 0 + self.successfulInteractions[source] = 1 if scraped else 0 + else: + if scraped: + self.totalScraped[source] += 1 + self.successfulInteractions[source] += 1 + + def set_limits_session( + self, + ): + """set the limits for current session""" + self.args.current_likes_limit = get_value( + getattr(self.args, "total_likes_limit", 300), None, 300 + ) + self.args.current_follow_limit = get_value( + getattr(self.args, "total_follows_limit", 50), None, 50 + ) + self.args.current_unfollow_limit = get_value( + getattr(self.args, "total_unfollows_limit", 50), None, 50 + ) + self.args.current_comments_limit = get_value( + getattr(self.args, "total_comments_limit", 10), None, 10 + ) + self.args.current_pm_limit = get_value(getattr(self.args, "total_pm_limit", 10), None, 10) + self.args.current_watch_limit = get_value( + getattr(self.args, "total_watches_limit", 50), None, 50 + ) + self.args.current_success_limit = get_value( + getattr(self.args, "total_successful_interactions_limit", 100), None, 100 + ) + self.args.current_total_limit = get_value( + getattr(self.args, "total_interactions_limit", 1000), None, 1000 + ) + self.args.current_scraped_limit = get_value( + getattr(self.args, "total_scraped_limit", 200), None, 200 + ) + self.args.current_crashes_limit = get_value( + getattr(self.args, "total_crashes_limit", 5), None, 5 + ) + + def check_limit(self, limit_type=None, output=False): + """Returns True if limit reached - else False""" + limit_type = SessionState.Limit.ALL if limit_type is None else limit_type + # check limits + total_likes = self.totalLikes >= int(self.args.current_likes_limit) + total_followed = sum(self.totalFollowed.values()) >= int( + self.args.current_follow_limit + ) + total_unfollowed = self.totalUnfollowed >= int(self.args.current_unfollow_limit) + total_comments = self.totalComments >= int(self.args.current_comments_limit) + total_pm = self.totalPm >= int(self.args.current_pm_limit) + total_watched = self.totalWatched >= int(self.args.current_watch_limit) + total_successful = sum(self.successfulInteractions.values()) >= int( + self.args.current_success_limit + ) + total_interactions = sum(self.totalInteractions.values()) >= int( + self.args.current_total_limit + ) + + total_scraped = sum(self.totalScraped.values()) >= int( + self.args.current_scraped_limit + ) + + total_crashes = self.totalCrashes >= int(self.args.current_crashes_limit) + + session_info = [ + "Checking session limits:", + f"- Total Likes:\t\t\t\t{'Limit Reached' if total_likes else 'OK'} ({self.totalLikes}/{self.args.current_likes_limit})", + f"- Total Comments:\t\t\t\t{'Limit Reached' if total_comments else 'OK'} ({self.totalComments}/{self.args.current_comments_limit})", + f"- Total PM:\t\t\t\t\t{'Limit Reached' if total_pm else 'OK'} ({self.totalPm}/{self.args.current_pm_limit})", + f"- Total Followed:\t\t\t\t{'Limit Reached' if total_followed else 'OK'} ({sum(self.totalFollowed.values())}/{self.args.current_follow_limit})", + f"- Total Unfollowed:\t\t\t\t{'Limit Reached' if total_unfollowed else 'OK'} ({self.totalUnfollowed}/{self.args.current_unfollow_limit})", + f"- Total Watched:\t\t\t\t{'Limit Reached' if total_watched else 'OK'} ({self.totalWatched}/{self.args.current_watch_limit})", + f"- Total Successful Interactions:\t\t{'Limit Reached' if total_successful else 'OK'} ({sum(self.successfulInteractions.values())}/{self.args.current_success_limit})", + f"- Total Interactions:\t\t\t{'Limit Reached' if total_interactions else 'OK'} ({sum(self.totalInteractions.values())}/{self.args.current_total_limit})", + f"- Total Crashes:\t\t\t\t{'Limit Reached' if total_crashes else 'OK'} ({self.totalCrashes}/{self.args.current_crashes_limit})", + f"- Total Successful Scraped Users:\t\t{'Limit Reached' if total_scraped else 'OK'} ({sum(self.totalScraped.values())}/{self.args.current_scraped_limit})", + ] + + if limit_type == SessionState.Limit.ALL: + if output: + for line in session_info: + logger.info(line) + + return ( + total_likes and getattr(self.args, "end_if_likes_limit_reached", False) + or total_followed and getattr(self.args, "end_if_follows_limit_reached", False) + or total_watched and getattr(self.args, "end_if_watches_limit_reached", False) + or total_comments and getattr(self.args, "end_if_comments_limit_reached", False) + or total_pm and getattr(self.args, "end_if_pm_limit_reached", False), + total_unfollowed, + total_interactions or total_successful or total_scraped, + ) + + elif limit_type == SessionState.Limit.LIKES: + if output: + logger.info(session_info[1]) + else: + logger.debug(session_info[1]) + return total_likes + + elif limit_type == SessionState.Limit.COMMENTS: + if output: + logger.info(session_info[2]) + else: + logger.debug(session_info[2]) + return total_comments + + elif limit_type == SessionState.Limit.PM: + if output: + logger.info(session_info[3]) + else: + logger.debug(session_info[3]) + return total_pm + + elif limit_type == SessionState.Limit.FOLLOWS: + if output: + logger.info(session_info[4]) + else: + logger.debug(session_info[4]) + return total_followed + + elif limit_type == SessionState.Limit.UNFOLLOWS: + if output: + logger.info(session_info[5]) + else: + logger.debug(session_info[5]) + return total_unfollowed + + elif limit_type == SessionState.Limit.WATCHES: + if output: + logger.info(session_info[6]) + else: + logger.debug(session_info[6]) + return total_watched + + elif limit_type == SessionState.Limit.SUCCESS: + if output: + logger.info(session_info[7]) + else: + logger.debug(session_info[7]) + return total_successful + + elif limit_type == SessionState.Limit.TOTAL: + if output: + logger.info(session_info[8]) + else: + logger.debug(session_info[8]) + return total_interactions + + elif limit_type == SessionState.Limit.CRASHES: + if output: + logger.info(session_info[9]) + else: + logger.debug(session_info[9]) + return total_crashes + + elif limit_type == SessionState.Limit.SCRAPED: + if output: + logger.info(session_info[10]) + else: + logger.debug(session_info[10]) + return total_scraped + + @staticmethod + def inside_working_hours(working_hours, delta_sec): + def time_in_range(start, end, x): + if start <= end: + return start <= x <= end + else: + return start <= x or x <= end + + in_range = False + time_left_list = [] + current_time = datetime.now() + delta = timedelta(seconds=delta_sec) + if not working_hours: + return True, 0 + + for n in working_hours: + today = current_time.strftime("%Y-%m-%d") + # 100% Autonomous: Hybrid Time Format Support (Legacy . vs Modern :) + h_start = n.split('-')[0].replace(":", ".") + h_end = n.split('-')[1].replace(":", ".") + + inf_value = f"{h_start} {today}" + inf = datetime.strptime(inf_value, "%H.%M %Y-%m-%d") + delta + sup_value = f"{h_end} {today}" + sup = datetime.strptime(sup_value, "%H.%M %Y-%m-%d") + delta + if sup - inf + timedelta(minutes=1) == timedelta( + days=1 + ) or sup - inf + timedelta(minutes=1) == timedelta(days=0): + logger.debug("Whole day mode.") + return True, 0 + if time_in_range(inf.time(), sup.time(), current_time.time()): + in_range = True + return in_range, 0 + else: + time_left = inf - current_time + if time_left >= timedelta(0): + time_left_list.append(time_left) + else: + time_left_list.append(time_left + timedelta(days=1)) + + return ( + in_range, + min(time_left_list) if len(time_left_list) > 1 else time_left_list[0], + ) + + def is_finished(self): + return self.finishTime is not None + + class Limit(Enum): + ALL = auto() + LIKES = auto() + COMMENTS = auto() + PM = auto() + FOLLOWS = auto() + UNFOLLOWS = auto() + WATCHES = auto() + SUCCESS = auto() + TOTAL = auto() + SCRAPED = auto() + CRASHES = auto() + + +class SessionStateEncoder(JSONEncoder): + def default(self, session_state: SessionState): + return { + "id": session_state.id, + "total_interactions": sum(session_state.totalInteractions.values()), + "successful_interactions": sum( + session_state.successfulInteractions.values() + ), + "total_followed": sum(session_state.totalFollowed.values()), + "total_likes": session_state.totalLikes, + "total_comments": session_state.totalComments, + "total_pm": session_state.totalPm, + "total_watched": session_state.totalWatched, + "total_unfollowed": session_state.totalUnfollowed, + "total_scraped": session_state.totalScraped, + "start_time": str(session_state.startTime), + "finish_time": str(session_state.finishTime), + "args": session_state.args.__dict__, + "profile": { + "posts": session_state.my_posts_count, + "followers": session_state.my_followers_count, + "following": session_state.my_following_count, + }, + } diff --git a/GramAddict/core/stealth_typing.py b/GramAddict/core/stealth_typing.py new file mode 100644 index 0000000..9c14eb8 --- /dev/null +++ b/GramAddict/core/stealth_typing.py @@ -0,0 +1,72 @@ +import logging +import random +from time import sleep + +logger = logging.getLogger(__name__) + +def ghost_type(device, text: str): + """ + Tesla Stealth Ghost Keyboard. + Bypasses UIAutomator virtual IME completely and sends raw Native InputEvents. + Features: Variable typing speed, burst chunking, and synthetic human mistakes. + """ + if not text: + return + + logger.info(f"⌨ī¸ [Ghost Keyboard] Initiating stealth injection ({len(text)} chars)...") + + # We slice text into variable-sized human bursts + chunks = [] + i = 0 + while i < len(text): + if random.random() < 0.15: + chunk_size = 1 # single letter hunting + else: + chunk_size = random.randint(2, 6) # fluid typing bursts + + chunks.append(text[i:i+chunk_size]) + i += chunk_size + + for idx, chunk in enumerate(chunks): + # 5% chance of a typo if it's an alphabetical chunk + if random.random() < 0.05 and len(chunk) >= 2 and chunk[-1].isalpha(): + typo_letter = random.choice('abcdefghijklmnopqrstuvwxyz') + # Add typo instead of actual last letter + typo_chunk = chunk[:-1] + typo_letter + _adb_inject_text(device, typo_chunk) + + # Realize mistake + sleep(random.uniform(0.2, 0.45)) + + # Send Backspace (KEYCODE_DEL = 67) + device.deviceV2.shell("input keyevent 67") + sleep(random.uniform(0.1, 0.25)) + + # Inject the correct character + _adb_inject_text(device, chunk[-1]) + else: + _adb_inject_text(device, chunk) + + # Realistic pause between semantic bursts (humans think while typing) + if chunk.endswith((" ", ".", ",", "!", "?")): + sleep(random.uniform(0.2, 0.5)) + else: + sleep(random.uniform(0.05, 0.18)) + + logger.debug("⌨ī¸ [Ghost Keyboard] Injection complete.") + +def _adb_inject_text(device, text: str): + if not text: + return + + # For Android `input text`, spaces must be mapped to %s + # Single quotes need to be bash escaped since we wrap the string in '' + # Special characters like & | > < \ ( ) { } ! must be carefully handled. + # The safest way is to let shell loop over characters or strictly replace. + safe_text = text.replace(" ", "%s").replace("'", "\\'") + + # Send through Android's native InputManager + try: + device.deviceV2.shell(["input", "text", safe_text]) + except Exception as e: + logger.debug(f"[Ghost Keyboard] Native injection failed: {e}") diff --git a/GramAddict/core/swarm_protocol.py b/GramAddict/core/swarm_protocol.py new file mode 100644 index 0000000..086b38c --- /dev/null +++ b/GramAddict/core/swarm_protocol.py @@ -0,0 +1,125 @@ +import logging +import os +import hashlib +import time +from typing import Optional +from colorama import Fore +from GramAddict.core.qdrant_memory import QdrantBase +from qdrant_client.models import PointStruct, Filter, FieldCondition, MatchValue + +logger = logging.getLogger(__name__) + + +class SwarmProtocol(QdrantBase): + """ + Decentralized Markov state-channel for P2P knowledge sharing. + + Manages 'Pheromones' (successful UI transitions and interactions) + and 'BannedPaths' (failed attempts) across bot sessions. + + This creates a Fleet Learning effect: every session learns from + every previous session's successes and failures. + """ + def __init__(self, username: str): + self.username = username + super().__init__(collection_name="gramaddict_swarm_pheromones", vector_size=4) + + + def emit_pheromone(self, path_hash: str, outcome: str): + """ + Broadcasting a successful UI transition or interaction to the fleet memory. + Future sessions can use this to avoid failed paths and repeat successful ones. + """ + if not self.is_connected or not self.client: + return + + try: + self.upsert_point( + seed_string=f"{path_hash}_{outcome}", + vector=[1.0, 0.0, 0.0, 0.0], # Dummy vector + payload={ + "path_hash": path_hash, + "outcome": outcome, + "username": self.username, + "timestamp": time.time(), + "count": 1, + }, + log_success=f"🌐 [Swarm] ⚡ Pheromone emitted: {path_hash[:16]} → {outcome}" + ) + except Exception as e: + logger.debug(f"[Swarm] Pheromone emit failed: {e}") + + + def query_consensus(self, path_hash: str) -> Optional[str]: + """ + Queries the swarm for historical outcomes of a specific path. + Returns the most recent outcome or None. + """ + if not self.is_connected or not self.client: + return None + + try: + points, _ = self.client.scroll( + collection_name=self.collection_name, + scroll_filter=Filter( + must=[ + FieldCondition( + key="path_hash", + match=MatchValue(value=path_hash) + ) + ] + ), + limit=1, + with_payload=True, + ) + + if points: + outcome = points[0].payload.get("outcome") + logger.info( + f"🌐 [Swarm] Consensus for {path_hash[:16]}: {outcome}", + extra={"color": f"{Fore.CYAN}"} + ) + return outcome + except Exception as e: + logger.debug(f"[Swarm] Consensus query failed: {e}") + + return None + + def sync_banned_paths(self, banned_paths_db): + """ + Pull globally banned paths from the swarm into local BannedPathsDB. + Ensures new sessions immediately know about failed paths. + """ + if not self.is_connected or not self.client: + return + + try: + points, _ = self.client.scroll( + collection_name=self.collection_name, + scroll_filter=Filter( + must=[ + FieldCondition( + key="outcome", + match=MatchValue(value="banned") + ) + ] + ), + limit=100, + with_payload=True, + ) + + synced = 0 + for pt in points: + payload = pt.payload or {} + path = payload.get("path_hash", "") + if path and banned_paths_db: + banned_paths_db.ban(path, "swarm_synced", reason="Synced from fleet memory") + synced += 1 + + if synced > 0: + logger.info( + f"🌐 [Swarm] Synced {synced} banned paths from fleet memory.", + extra={"color": f"{Fore.CYAN}"} + ) + except Exception as e: + logger.debug(f"[Swarm] Banned path sync failed: {e}") diff --git a/GramAddict/core/telepathic_engine.py b/GramAddict/core/telepathic_engine.py new file mode 100644 index 0000000..fab0c21 --- /dev/null +++ b/GramAddict/core/telepathic_engine.py @@ -0,0 +1,652 @@ +import logging +import xml.etree.ElementTree as ET +import math +import re +import base64 +import json +import os +import time +from typing import Optional, Tuple, Dict, Any +from GramAddict.core.qdrant_memory import QdrantBase +from GramAddict.core.llm_provider import query_telepathic_llm +from GramAddict.core.diagnostic_dump import dump_ui_state + +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.92 # Bottom 8% = Android nav bar / Instagram bottom tabs +MAX_BUTTON_AREA = 150000 # Buttons/icons should be smaller than this (px²) +MAX_CONTAINER_AREA = 500000 # Anything above this is a full-screen container + +# Cache files +MEMORY_FILE = "telepathic_memory.json" +BLACKLIST_FILE = "telepathic_blacklist.json" + + +class TelepathicEngine: + """ + Project Singularity V9: 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. + 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 + 3. Negative learning — failed clicks are blacklisted and never repeated + 4. Positive reinforcement — confirmed clicks are cached for instant recall + + The engine never trusts a VLM output blindly. It returns candidates, + and the caller uses `confirm_click()` or `reject_click()` to teach it. + """ + _instance = None + _last_click_context: Optional[dict] = None # Tracks what we last returned for feedback + + @classmethod + def get_instance(cls): + if cls._instance is None: + cls._instance = cls() + return cls._instance + + def __init__(self): + self.embedding_helper = QdrantBase("telepathic_engine_cache") + self._embedding_cache: Dict[str, list] = {} + self._intent_cache: Dict[str, list] = {} + # Load blacklist (negative learnings) into memory + self._blacklist = self._load_json(BLACKLIST_FILE) + # Load positive cache + self._memory = self._load_json(MEMORY_FILE) + + # ────────────────────────────────────────────── + # Core Math + # ────────────────────────────────────────────── + + def _cosine_similarity(self, v1: list, v2: list) -> float: + if not v1 or not v2 or len(v1) != len(v2): + return 0.0 + dot_product = sum(a * b for a, b in zip(v1, v2)) + magnitude_v1 = math.sqrt(sum(a * a for a in v1)) + magnitude_v2 = math.sqrt(sum(b * b for b in v2)) + if magnitude_v1 == 0 or magnitude_v2 == 0: + return 0.0 + return dot_product / (magnitude_v1 * magnitude_v2) + + def _get_cached_embedding(self, text: str, is_intent: bool = False) -> Optional[list]: + cache = self._intent_cache if is_intent else self._embedding_cache + if text in cache: + return cache[text] + if len(self._embedding_cache) > 2000: + self._embedding_cache.clear() + vec = self.embedding_helper._get_embedding(text) + if vec: + cache[text] = vec + return vec + + # ────────────────────────────────────────────── + # Persistent JSON helpers + # ────────────────────────────────────────────── + + @staticmethod + def _load_json(path: str) -> dict: + try: + if os.path.exists(path): + with open(path, "r") as f: + return json.load(f) + except Exception: + pass + return {} + + @staticmethod + def _save_json(path: str, data: dict): + try: + with open(path, "w") as f: + json.dump(data, f, indent=4) + except Exception as e: + logger.warning(f"Could not save {path}: {e}") + + # ────────────────────────────────────────────── + # XML Parsing + # ────────────────────────────────────────────── + + def _extract_semantic_nodes(self, xml_string: str) -> list[dict]: + """Parses Android UI XML and extracts clickable/interactive nodes.""" + nodes = [] + try: + clean_xml = re.sub(r'<\?xml.*?\?>', '', xml_string).strip() + root = ET.fromstring(clean_xml) + + for elem in root.iter('node'): + attrib = elem.attrib + text = attrib.get('text', '').strip() + content_desc = attrib.get('content-desc', '').strip() + res_id = attrib.get('resource-id', '').strip() + class_name = attrib.get('class', '').strip() + + clickable = attrib.get('clickable', 'false') == 'true' + scrollable = attrib.get('scrollable', 'false') == 'true' + long_clickable = attrib.get('long-clickable', 'false') == 'true' + + semantic_res = res_id and any(x in res_id.lower() for x in ['button', 'tab', 'icon', 'action', 'menu']) + has_semantic_weight = bool(content_desc or semantic_res) + + if not (clickable or scrollable or long_clickable or has_semantic_weight): + continue + + if not text and not content_desc and not res_id: + continue + + desc_parts = [] + if text: desc_parts.append(f"text: '{text}'") + if content_desc: desc_parts.append(f"description: '{content_desc}'") + if res_id: + clean_id = res_id.split('/')[-1].replace('_', ' ') + desc_parts.append(f"id context: '{clean_id}'") + + semantic_string = ", ".join(desc_parts) + if not semantic_string: + continue + + bounds_str = attrib.get('bounds', '') + match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds_str) + if not match: + continue + + left, top, right, bottom = map(int, match.groups()) + center_x = (left + right) // 2 + center_y = (top + bottom) // 2 + width = right - left + height = bottom - top + + nodes.append({ + "semantic_string": semantic_string, + "x": center_x, + "y": center_y, + "width": width, + "height": height, + "area": width * height, + "raw_bounds": bounds_str, + "resource_id": res_id, + "class_name": class_name, + "original_attribs": {"text": text, "desc": content_desc} + }) + except Exception as e: + logger.error(f"Telepathic XML parsing failed: {e}") + + return nodes + + # ────────────────────────────────────────────── + # Structural Sanity (app-agnostic, no hardcoded IDs) + # ────────────────────────────────────────────── + + def _structural_sanity_check(self, node: dict, intent_description: str, screen_height: int = 2400) -> bool: + """ + App-agnostic structural validation. Checks physical properties + (size, position, element class) — NOT resource-ID strings. + + Returns False if the node is structurally implausible as a click target. + """ + # 1. Reject massive containers (full-screen views, recycler views) + # UNLESS the intent explicitly targets media + is_media_intent = any(k in intent_description.lower() for k in ["video", "photo", "reel", "media", "post"]) + 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: + return False + + # 3. Reject nodes with zero area (invisible) + if node.get("area", 0) == 0: + return False + + return True + + def _is_blacklisted(self, intent: str, semantic_string: str) -> bool: + """Checks if this intent→node mapping was previously rejected via negative learning.""" + blacklisted = self._blacklist.get(intent, []) + return semantic_string in blacklisted + + # ────────────────────────────────────────────── + # App Context Guard + # ────────────────────────────────────────────── + + def _is_instagram_context(self, nodes: list[dict]) -> bool: + """ + Returns True only if the extracted nodes appear to come from the target app. + Checks for the presence of the dynamic app_id in resource-ID prefixes. + """ + app_id = getattr(self, "_cached_app_id", None) + if not app_id: + from GramAddict.core.config import Config + try: + cfg = Config() + app_id = cfg.args.app_id if hasattr(cfg, "args") and hasattr(cfg.args, "app_id") else "com.instagram.android" + except Exception: + app_id = "com.instagram.android" + self._cached_app_id = app_id + + for n in nodes: + rid = n.get("resource_id", "") + if app_id in rid: + return True + return False + + # ────────────────────────────────────────────── + # Stage 0: Deterministic Keyword Fast Path + # ────────────────────────────────────────────── + + def _keyword_match_score(self, intent_description: str, nodes: list[dict]) -> Optional[dict]: + """ + Pure string-matching stage. Extracts keywords from the intent and + matches them against node text, description, and resource-id. + Returns the best matching node as a result dict, or None. + + This eliminates ~90% of embedding/VLM calls for common UI intents. + ZERO AI cost — runs entirely on CPU string ops. + """ + # Extract meaningful keywords from intent (strip common filler words) + filler = {"tap", "the", "button", "tab", "on", "in", "a", "an", "of", "for", "to", "and", "or", "input", "text", "box"} + intent_words = set(w.lower() for w in re.split(r'\W+', intent_description) if w and w.lower() not in filler and len(w) > 1) + + if not intent_words: + return None + + # Expand known Instagram aliases to avoid sending UI basics to the LLM mappings + aliases = { + "reels": ["clips", "reel"], + "explore": ["search"], + "home": ["main"], + "like": ["heart"], + "comment": ["reply"], + "profile": ["user", "account"], + } + + scored = [] + for node in nodes: + sem = node.get("semantic_string", "").lower() + rid = node.get("resource_id", "").lower().replace("_", " ") + desc_text = node.get("original_attribs", {}).get("desc", "").lower() + node_text = node.get("original_attribs", {}).get("text", "").lower() + + # Combine all searchable fields + searchable = f"{sem} {rid} {desc_text} {node_text}" + + # Count how many intent keywords appear in the node's text (including aliases) + hits = 0 + for w in intent_words: + if w in searchable: + hits += 1 + elif w in aliases: + for alias in aliases[w]: + if alias in searchable: + hits += 1 + break + + if hits == 0: + continue + + # Score = ratio of intent keywords matched + score = hits / len(intent_words) + + # Require at least 40% keyword overlap to avoid false positives + if score >= 0.4: + scored.append((node, score)) + + if not scored: + return None + + # Sort by score desc, then by area asc (prefer smallest/most atomic) + scored.sort(key=lambda x: (-x[1], x[0].get("area", 999999))) + best_node, best_score = scored[0] + + # Check for already-liked state + if "like" in intent_description.lower(): + desc = best_node.get("original_attribs", {}).get("desc", "").lower() + text = best_node.get("original_attribs", {}).get("text", "").lower() + if "liked" in desc or "liked" in text: + logger.info("⏭ī¸ [Keyword Fast Path] Post is already Liked. Skipping.") + return {"x": None, "y": None, "score": 1.0, "semantic": "already_liked", "skip": True} + + logger.info(f"⚡ [Keyword Fast Path] Instant match for '{intent_description}' → {best_node['semantic_string']} (KeyScore: {best_score:.2f})") + self._track_click(intent_description, best_node) + return { + "x": best_node["x"], + "y": best_node["y"], + "score": 0.95, # High confidence — deterministic match + "semantic": best_node["semantic_string"], + "area": best_node.get("area", 0), + "source": "keyword" + } + + # ────────────────────────────────────────────── + # Core: Find Best Node + # ────────────────────────────────────────────── + + def find_best_node(self, xml_hierarchy: str, intent_description: str, min_confidence: float = 0.82, device=None) -> Optional[dict]: + """ + Scans the screen and returns the center coordinates (x, y) of the node + whose embedding is most mathematically similar to the intent. + + Resolution cascade (ordered by speed & reliability): + 1. Positive Memory Cache (past CONFIRMED clicks) + 2. Keyword Fast Path (deterministic string matching) + 3. Vector Similarity Engine (embedding cosine similarity) + 4. Vision Cortex Fallback (VLM, with structural guards) + + All results are PROVISIONAL until the caller confirms via confirm_click(). + Failed clicks should be reported via reject_click(). + """ + logger.debug(f"[TelepathicEngine] Seeking intent: '{intent_description}'") + + interactive_nodes = self._extract_semantic_nodes(xml_hierarchy) + if not interactive_nodes: + logger.debug("[TelepathicEngine] Screen contains no interactable semantic nodes.") + return None + + # 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: + screen_height = int(max_y * 1.05) + + # Pre-filter: Remove structurally implausible nodes and blacklisted mappings + viable_nodes = [] + for node in interactive_nodes: + if not self._structural_sanity_check(node, intent_description, screen_height): + continue + if self._is_blacklisted(intent_description, node["semantic_string"]): + logger.debug(f"đŸšĢ [Blacklist] Skipping known-bad mapping: '{intent_description}' → '{node['semantic_string']}'") + continue + viable_nodes.append(node) + + if not viable_nodes: + logger.warning(f"[TelepathicEngine] No viable nodes left after filtering for '{intent_description}'") + return None + + # ── App Context Guard: Abort if NOT in Target App ── + if not self._is_instagram_context(interactive_nodes): + if device: + current_app = device._get_current_app() + if current_app != device.app_id: + logger.warning(f"⚠ī¸ [Context Guard] Not in target app (Current: {current_app}). Aborting AI lookup for '{intent_description}'.") + return None + else: + 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} + + 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 1.5: Deterministic Keyword Fast Path ── + fast_path_result = self._keyword_match_score(intent_description, viable_nodes) + if fast_path_result: + return fast_path_result + + # ── Stage 2: Vector Similarity Engine ── + intent_vec = self._get_cached_embedding(intent_description, is_intent=True) + if intent_vec: + scored_nodes = [] + for node in viable_nodes: + node_vec = self._get_cached_embedding(node["semantic_string"]) + if not node_vec: + continue + score = self._cosine_similarity(intent_vec, node_vec) + scored_nodes.append((node, score)) + + # Sort by score descending + scored_nodes.sort(key=lambda x: x[1], reverse=True) + + # Update viable_nodes so that the VLM fallback gets the top semantic candidates + viable_nodes = [n for n, s in scored_nodes] + + # Among high-confidence matches, prefer smaller/more atomic elements + if scored_nodes and scored_nodes[0][1] >= min_confidence: + # Get all nodes within 0.05 of the top score + top_score = scored_nodes[0][1] + top_tier = [(n, s) for n, s in scored_nodes if s >= top_score - 0.05] + + # Among equally-scored candidates, prefer the smallest (most atomic) + top_tier.sort(key=lambda x: x[0].get("area", 999999)) + best_node, best_score = top_tier[0] + + # Prevent un-liking + if "like" in intent_description.lower() and re.search( + r"\b(liked|gefällt mir nicht mehr)\b", + best_node["semantic_string"].lower() + ): + logger.info("⏭ī¸ [Telepathic] Post is already Liked. Skipping.") + return {"x": None, "y": None, "score": 1.0, "semantic": "already_liked", "skip": True} + + logger.info(f"✨ [Telepathic Match] '{intent_description}' ➔ {best_node['semantic_string']} (Score: {best_score:.3f})") + self._track_click(intent_description, best_node) + return { + "x": best_node["x"], + "y": best_node["y"], + "score": best_score, + "semantic": best_node["semantic_string"], + "source": "vector" + } + elif scored_nodes: + logger.warning(f"⚠ī¸ [Telepathic] Low confidence ({scored_nodes[0][1]:.3f} < {min_confidence}) for '{intent_description}'.") + + # ── Stage 3: Telepathic LLM Fallback (Text-Based XML Reasoning) ── + if device: + logger.info(f"🧠 [Agentic Fallback] Activating structural LLM reasoning for: '{intent_description}'") + return self._vision_cortex_fallback(intent_description, viable_nodes, device, screen_height) + + return None + + # ────────────────────────────────────────────── + # Click Tracking & Feedback Loop + # ────────────────────────────────────────────── + + 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 = { + "intent": intent, + "semantic_string": node["semantic_string"], + "x": node["x"], + "y": node["y"], + "timestamp": time.time() + } + + def confirm_click(self, intent: str = None): + """ + Called by the interaction layer AFTER verifying the click produced the expected result. + Stores the mapping as a confirmed positive learning. + + Usage: + result = telepathic.find_best_node(xml, "tap like button", device=device) + _humanized_click(device, result["x"], result["y"]) + # ... verify the like actually happened ... + telepathic.confirm_click("tap like button") + """ + ctx = TelepathicEngine._last_click_context + if not ctx: + return + + actual_intent = intent or ctx["intent"] + sem = ctx["semantic_string"] + + # Add to positive memory + 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}'") + + # Remove from blacklist if it was there (rehabilitation) + if actual_intent in self._blacklist and sem in self._blacklist[actual_intent]: + self._blacklist[actual_intent].remove(sem) + self._save_json(BLACKLIST_FILE, self._blacklist) + logger.debug(f"🔄 [Rehabilitation] Removed from blacklist: '{actual_intent}' → '{sem}'") + + TelepathicEngine._last_click_context = None + + def reject_click(self, intent: str = None): + """ + Called by the interaction layer when the click did NOT produce the expected result. + Adds the mapping to the blacklist (negative learning) so it's never tried again. + Also removes it from positive memory if it was cached there. + + Usage: + result = telepathic.find_best_node(xml, "tap comment button", device=device) + _humanized_click(device, result["x"], result["y"]) + # ... verify comment sheet did NOT open ... + telepathic.reject_click("tap comment button") + """ + ctx = TelepathicEngine._last_click_context + if not ctx: + return + + actual_intent = intent or ctx["intent"] + sem = ctx["semantic_string"] + + # Add to blacklist + if actual_intent not in self._blacklist: + self._blacklist[actual_intent] = [] + if sem not in self._blacklist[actual_intent]: + self._blacklist[actual_intent].append(sem) + self._save_json(BLACKLIST_FILE, self._blacklist) + logger.warning(f"đŸšĢ [Negative Learning] Blacklisted: '{actual_intent}' → '{sem}'") + + # 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}'") + + TelepathicEngine._last_click_context = None + + # ────────────────────────────────────────────── + # Vision Cortex Fallback (VLM) + # ────────────────────────────────────────────── + + def _vision_cortex_fallback(self, intent: str, nodes: list[dict], device, screen_height: int = 2400) -> Optional[dict]: + """ + Uses a Language Model to identify the correct node from parsed screen XML + when embeddings are insufficient. 100% Screenshot-free for maximum speed and zero hallucination. + + Guards are STRUCTURAL (size, position, class) not ID-based. + Learning happens via the confirm/reject feedback loop, not here. + """ + try: + # Limit to 20 nodes for token efficiency + simplified_nodes = [] + for i, n in enumerate(nodes[:20]): + simplified_nodes.append({ + "index": i, + "bounds": n["raw_bounds"], + "semantic": n["semantic_string"] + }) + + # Get model config + from GramAddict.core.config import Config + try: + args = Config().args + except Exception: + args = None + model = getattr(args, "ai_telepathic_model", "google/gemini-3.1-flash-lite-preview") if args else "google/gemini-3.1-flash-lite-preview" + url = getattr(args, "ai_telepathic_url", "https://openrouter.ai/api/v1/chat/completions") if args else "https://openrouter.ai/api/v1/chat/completions" + if device and hasattr(device, 'args') and device.args: + model = getattr(device.args, "ai_telepathic_model", model) + url = getattr(device.args, "ai_telepathic_url", url) + + system_prompt = ( + "You identify which UI element to tap based ONLY on a JSON array of parsed Android elements. " + "Each element has an 'index', structural 'bounds', and a 'semantic' description. " + "Output ONLY valid JSON containing the exact `index` to interact with, and a `reason`. " + ) + + user_prompt = ( + f"Which element should I tap to: {intent}\n\n" + f"Elements:\n{json.dumps(simplified_nodes, indent=1)}\n\n" + "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" + "Return: {\"index\": number, \"reason\": \"...\"}" + ) + + resp_str = query_telepathic_llm(model, url, system_prompt, user_prompt) + data = json.loads(resp_str) + + idx = data.get("index") + if idx is not None and 0 <= idx < len(nodes): + match = nodes[idx] + + # ── 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 " + f"({match.get('width')}x{match.get('height')}): {match['semantic_string']}. REJECTING." + ) + dump_ui_state(device, "vlm_hallucination", { + "intent": intent, + "rejected_node": match["semantic_string"], + "node_size": f"{match.get('width')}x{match.get('height')}", + "vlm_index": idx + }) + return None + + # ── Structural Guard 2: Position (status bar) ── + if match.get("y", 0) < screen_height * STATUS_BAR_ZONE: + logger.error( + f"❌ [Structural Guard] VLM selected element in status bar zone " + f"(y={match.get('y')}): {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: " + f"'{match['semantic_string']}'. REJECTING." + ) + return None + + logger.info(f"đŸŽ¯ [Vision Success] VLM identified node {idx} for '{intent}': {match['semantic_string']}") + + # Track but do NOT auto-cache. Wait for confirm_click() from caller. + self._track_click(intent, match) + + return { + "x": match["x"], + "y": match["y"], + "score": 0.85, # Not 1.0 — VLM is provisional, not ground truth + "semantic": f"VLM Match: {match['semantic_string']}", + "source": "agentic_fallback" + } + + except Exception as e: + logger.error(f"[Vision Cortex] Fallback failed: {e}") + + return None diff --git a/GramAddict/core/unfollow_engine.py b/GramAddict/core/unfollow_engine.py new file mode 100644 index 0000000..36dbac6 --- /dev/null +++ b/GramAddict/core/unfollow_engine.py @@ -0,0 +1,113 @@ +import logging +import random +import time +from colorama import Fore, Style +from GramAddict.core.session_state import SessionState + +logger = logging.getLogger(__name__) + +def _humanized_scroll_down(device): + # Same as bot_flow._humanized_scroll but strictly downward + info = device.get_info() + w, h = info.get("displayWidth", 1080), info.get("displayHeight", 2400) + start_x = int(w * 0.8) + device.cm_to_pixels(random.uniform(-0.3, 0.3)) + start_y = int(h * 0.7) + device.cm_to_pixels(random.uniform(-0.5, 0.5)) + end_y = int(h * 0.2) + device.cm_to_pixels(random.uniform(-0.5, 0.5)) + duration = random.uniform(0.08, 0.12) + device.deviceV2.swipe(start_x, start_y, start_x, end_y, duration) + from GramAddict.core.bot_flow import sleep + sleep(1.0) + +def _run_zero_latency_unfollow_loop(device, zero_engine, nav_graph, configs, session_state, current_target, cognitive_stack): + """ + Executes the autonomous Unfollow logic in the Zero-Latency architecture. + Assumes the bot is already at the "FollowingList" UI state. + """ + logger.info(f"🧠 [Unfollow Engine] Initiating cleanup routine in {current_target}...", extra={"color": f"{Style.BRIGHT}{Fore.CYAN}"}) + + telepathic = cognitive_stack.get("telepathic") + dopamine = cognitive_stack.get("dopamine") + + unfollow_limit = int(getattr(configs.args, "total_unfollows_limit", 50)) + failed_scrolls = 0 + total_unfollowed_this_session = 0 + + from GramAddict.core.bot_flow import sleep, dump_ui_state, _humanized_click + + # Initialize basic tuple if it's missing (helps with tests and initializations) + if not hasattr(session_state, 'totalUnfollowed'): + session_state.totalUnfollowed = 0 + + while not dopamine.is_app_session_over(): + # Check global limit tuple logic + limit_val = session_state.check_limit(SessionState.Limit.UNFOLLOWS) + if isinstance(limit_val, tuple) and limit_val[0]: + logger.info("🛑 Unfollow limit reached for session. Yielding control.") + return "BOREDOM_CHANGE_FEED" + elif limit_val is True: + logger.info("🛑 Unfollow limit reached for session. Yielding control.") + return "BOREDOM_CHANGE_FEED" + + if total_unfollowed_this_session >= unfollow_limit: + logger.info("🛑 Configured unfollow limit reached. Yielding control.") + return "BOREDOM_CHANGE_FEED" + + try: + xml_dump = device.deviceV2.dump_hierarchy() + + # Use Telepathic Engine to explicitly locate existing "Following" buttons in lists + nodes = telepathic._extract_semantic_nodes(xml_dump, "find 'Following' buttons next to usernames", threshold=0.7) + + action_taken = False + for node in nodes: + # Basic validation it's an interactive button + if node.get("skip") or not node.get("bounds"): + continue + + # Tap the first valid following button we see + _humanized_click(device, node["x"], node["y"]) + action_taken = True + logger.debug(f"👆 Tapped following button at ({node['x']}, {node['y']})") + + # Check for confirmation dialog ("Unfollow @username?") + sleep(1.5) + confirm_xml = device.deviceV2.dump_hierarchy() + confirm_nodes = telepathic._extract_semantic_nodes(confirm_xml, "find 'Unfollow' confirmation button", threshold=0.8) + + if confirm_nodes and not confirm_nodes[0].get("skip"): + c_node = confirm_nodes[0] + _humanized_click(device, c_node["x"], c_node["y"]) + sleep(1.0) + + logger.info("✅ [Unfollow Engine] Unfollowed a user in list.", extra={"color": Fore.GREEN}) + session_state.totalUnfollowed += 1 + total_unfollowed_this_session += 1 + failed_scrolls = 0 + + # Unfollow cost logic + dopamine.boredom += random.uniform(1.0, 3.0) + sleep(2.0) + break + + if not action_taken: + # No following buttons in view, scroll down to find more + _humanized_scroll_down(device) + dopamine.boredom += 0.5 + failed_scrolls += 1 + + if failed_scrolls > 5: + logger.warning("⚠ī¸ [Unfollow Engine] No 'Following' buttons found after multiple scrolls. Aborting or reaching bottom.") + return "BOREDOM_CHANGE_FEED" + + if dopamine.wants_to_change_feed(): + logger.info("🧠 [Unfollow Engine] Desire to clean up following list satisfied. Navigating elsewhere.") + return "BOREDOM_CHANGE_FEED" + + except Exception as e: + logger.error(f"⚠ī¸ [FSD Anomaly Handler] Exception in Unfollow Loop: {e}") + _humanized_scroll_down(device) + failed_scrolls += 1 + if failed_scrolls > 3: + return "CONTEXT_LOST" + + return "SESSION_OVER" diff --git a/GramAddict/core/utils.py b/GramAddict/core/utils.py new file mode 100644 index 0000000..68381b5 --- /dev/null +++ b/GramAddict/core/utils.py @@ -0,0 +1,83 @@ +import logging +import random +import requests +import sys +from datetime import datetime, timedelta +from time import sleep +from colorama import Fore, Style +from packaging.version import parse as parse_version +from GramAddict.core.version import __version__ + +logger = logging.getLogger(__name__) + +def sanitize_text(text): + return (text or "").strip() + +def random_sleep(inf=1.0, sup=3.0, modulable=True): + from GramAddict.core.config import Config + configs = Config() + try: + multiplier = float(getattr(configs.args, "speed_multiplier", 1.0)) + except (ValueError, TypeError): + multiplier = 1.0 + delay = random.uniform(inf, sup) / (multiplier if modulable else 1.0) + sleep(max(delay, 0.2)) + +def config_examples(): + logger.debug("Config examples handled by documentation.") + +def check_if_updated(): + logger.info(f"GramAddict v.{__version__}", extra={"color": f"{Style.BRIGHT}{Fore.MAGENTA}"}) + +def get_instagram_version(device): + try: + output = device.deviceV2.shell(f"dumpsys package {device.app_id}").output + import re + version_match = re.findall("versionName=(\\S+)", output) + return version_match[0] if version_match else "unknown" + except Exception: + return "unknown" + +def close_instagram(device, force_kill=False): + if force_kill: + logger.info("Force-closing Instagram app to clean session state.") + try: + device.deviceV2.app_stop(device.app_id) + except Exception as e: + logger.debug(f"Error closing app: {e}") + else: + logger.info("Backgrounding Instagram app (minimizing).") + try: + device.deviceV2.press("home") + except Exception as e: + logger.debug(f"Error pressing home: {e}") + +def open_instagram(device, force_restart=False): + if force_restart: + logger.info("Opening Instagram app (Fresh Start).") + close_instagram(device, force_kill=True) + device.deviceV2.app_start(device.app_id) + random_sleep(3, 5, modulable=False) + else: + logger.info("Bringing Instagram app to foreground.") + device.deviceV2.app_start(device.app_id) + random_sleep(1, 2, modulable=False) + return True + +def set_time_delta(args): + args.time_delta_session = random.randint(-300, 300) + +def wait_for_next_session(time_left, session_state, sessions, device): + logger.info(f"Waiting {time_left} until next working hours.") + sleep(60) + +def get_value(count, name, default=0): + if count is None: return default + if isinstance(count, (int, float)): return count + try: + if "-" in str(count): + parts = str(count).split("-") + return random.randint(int(parts[0]), int(parts[1])) + return int(count) + except Exception: + return default diff --git a/GramAddict/core/version.py b/GramAddict/core/version.py new file mode 100644 index 0000000..e0c2680 --- /dev/null +++ b/GramAddict/core/version.py @@ -0,0 +1,2 @@ +__version__ = "7.0.0" +__tested_ig_version__ = "300.0.0.29.110" diff --git a/GramAddict/core/zero_latency_engine.py b/GramAddict/core/zero_latency_engine.py new file mode 100644 index 0000000..88ae879 --- /dev/null +++ b/GramAddict/core/zero_latency_engine.py @@ -0,0 +1,71 @@ +import logging +import re +import xml.etree.ElementTree as ET + +logger = logging.getLogger(__name__) + +class ZeroLatencyEngine: + """ + Project Singularity V7: 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. + """ + def __init__(self, device): + self.device = device + + def evaluate_heuristic(self, rule: dict, context_xml: str): + """ + Executes a compiled heuristic rule against the provided XML dump. + Rule schema: {"rule_type": "regex", "target_attribute": "text", "pattern": "..."} + Returns True/False for intent (e.g. is_ad, is_liked), or extracted strings (e.g. post_owner). + """ + if not rule or not context_xml: + return None + + rule_type = rule.get("rule_type", "regex") + target_attr = rule.get("target_attribute", "text") + pattern = rule.get("pattern", "") + + if not pattern: + return None + + try: + root = ET.fromstring(context_xml) + + if rule_type == "regex": + # Remove (?i) if present because we compile with re.IGNORECASE anyway + clean_pattern = pattern.replace('(?i)', '') + regex = re.compile(clean_pattern, re.IGNORECASE) + for node in root.iter("node"): + val = "" + if target_attr == "text": + val = node.attrib.get("text", "") + elif target_attr == "content-desc": + val = node.attrib.get("content-desc", "") + elif target_attr == "resource-id": + val = node.attrib.get("resource-id", "") + else: + # Fallback all + val_text = node.attrib.get("text", "") + val_desc = node.attrib.get("content-desc", "") + val_resid = node.attrib.get("resource-id", "") + val = f"{val_text} | {val_desc} | {val_resid}" + + match = regex.search(val) + if match: + if len(match.groups()) > 0: + return match.group(1) # Return captured group (e.g., username) + return True # Return boolean existence (e.g. is_ad) + + elif rule_type == "xpath": + # Basic xpath parsing over ET + nodes = root.findall(pattern) + if nodes: + return nodes[0].attrib.get(target_attr, "") + + return False # Rule ran but found nothing + + except Exception as e: + logger.debug(f"ZeroLatencyEngine failed to evaluate rule {pattern}: {e}") + return None diff --git a/GramAddict/plugins/plugin.example b/GramAddict/plugins/plugin.example new file mode 100644 index 0000000..c6b7a32 --- /dev/null +++ b/GramAddict/plugins/plugin.example @@ -0,0 +1,38 @@ +from GramAddict.core.plugin_loader import Plugin + + +class ExamplePlugin(Plugin): + """Short explanation that shows up on start""" + + def __init__(self): + super().__init__() + self.description = ( + "Description that currently has no use - can be same as above." + ) + self.arguments = [ + # + # argparse arguments + # + # Example of operation (a plugin that does something - like interact with followers) + { + "arg": "--interact", + "nargs": None, # see argparse docs for usage - if not needed use None + "help": "help message that explains what it does", + "metavar": None, # see argparse docs for usage - if not needed use None + "default": None, # see argparse docs for usage - if not needed use None + "operation": True, # If the argument is an operation, set to true. Otherwise do not include + }, + # Example of argparse "action" (something that requires no arguments) + { + "arg": "--screen-sleep", + "help": "save your screen by turning it off during the inactive time, disabled by default", + "action": "store_true", # see argparse docs for usage + }, + ] + + def run(self, device, configs, storage, sessions, profile_filter, plugin): + # Your code here. All variables above must be in function definition, but + # do not have to be used. If not needed, just ignore it. If you need anything + # else from the main script - please include it in __init__.py and update + # the run definition on all other plugins. + pass diff --git a/GramAddict/version.py b/GramAddict/version.py new file mode 100644 index 0000000..5e81a46 --- /dev/null +++ b/GramAddict/version.py @@ -0,0 +1,2 @@ +# that file is deprecated, current version is now stored in GramAddict/__init__.py +__version__ = "3.2.12" diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..8984921 --- /dev/null +++ b/LICENSE @@ -0,0 +1,23 @@ +MIT License + +Copyright (c) 2020 Alexander Mishchenko +Copyright (c) 2020 GramAddict - Philip Ulrich, Arthur Silva, Dennis Grasso + + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..6ee95cc --- /dev/null +++ b/README.md @@ -0,0 +1,57 @@ +

+
+

GramPilot

+
+

Full Self-Driving for Instagram.
An autonomous Agentic Engine that navigates the Instagram App like a human.

+

Originally derived from GramAddict, completely re-architected.

+

Created by Marc Mintel <marc@mintel.me>

+

+ +--- + +## 🏎ī¸ What is GramPilot? + +GramPilot is not a traditional script. Traditional bots rely on fixed UI locators (like XPaths) or external APIs, causing them to crash with every Instagram update or get banned within days. + +GramPilot introduces a **Telepathic Full Self-Driving (FSD) approach** to UI navigation: +It uses a 3-Stage Resolution Cascade backed by CPU Fast-Paths, Ollama Vector Similarity, and OpenRouter LLMs (Gemini/Qwen) to "read" the screen, understand context, and learn new UI layouts asynchronously. + +If Instagram updates its app and moves a button, GramPilot doesn't crash. It falls back to its Agentic LLM reasoning, dynamically reasons about the new layout using raw XML structure, clicks the right button, and never hallucinates on that button again. + +## ✨ Core Features + +* đŸšĢ **Zero Limits Configuration**: Forget about configuring "max_likes" or "delays". GramPilot uses a **Dopamine Pacing Engine** to simulate human boredom. If the content isn't interesting, it skips it or ends the session early. +* ⚖ī¸ **Active Inference (Shadow Mode)**: The bot continuously predicts the outcome of its clicks. If it lands on a popup instead of a profile, it registers a "Prediction Error", presses back, and dynamically recalibrates without panicking. +* ⛩ī¸ **Telepathic Engine**: A strictly tiered resolution cascade (Keyword -> Vectors -> LLM) that ensures 90% of navigation happens at 0-token cost while maintaining fallback AI resilience. +* đŸ§Ŧ **Resonance Oracle**: The bot only interacts with content that matches a pre-defined persona aesthetic, completely bypassing spam or low-quality content. +* 🛡ī¸ **Honeypot Radome**: Instagram plants invisible, 1x1 pixel trap buttons for bots. Our *Radome Sensor* sanitizes the XML view before the agent ever sees it, mathematically guaranteeing evasion of tracker traps. + +## 🚀 Quick Start + +### Prerequisites +* A physical Android device or emulator +* Python 3.10+ +* `adb` (Android Debug Bridge) installed and added to your PATH + +### Installation + +1. **Clone the repository:** + ```bash + git clone https://github.com/marcmintel/grampilot.git + cd grampilot + ``` + +2. **Initialize Environment & Dependencies:** + ```bash + python3 -m venv .venv + source .venv/bin/activate + pip install -r requirements.txt + ``` + +3. **Start the Engine:** + ```bash + python3 run.py --config config.yml + ``` + +> [!NOTE] +> Unlike legacy bots, GramPilot requires zero maintenance. It will automatically re-learn the UI over time using its integrated Qdrant memory vectors. diff --git a/ai_context/hintergrund.md b/ai_context/hintergrund.md new file mode 100644 index 0000000..cde327f --- /dev/null +++ b/ai_context/hintergrund.md @@ -0,0 +1,10 @@ +# Mein Profil +Wir sind Marisa und Marc, ein Digital-Nomad Paar aus Deutschland. + +# Thematik der Kommentare +Ich kommentiere bei anderen Accounts, die ebenfalls posten Ãŧber: +- Reisen +- Fotografie / Drohnenaufnahmen +- Digital Nomads + +Gehe gerne auf Details aus der Bildbeschreibung ein, um zu zeigen, dass du den Post echt gelesen hast! diff --git a/ai_context/tone_of_voice.md b/ai_context/tone_of_voice.md new file mode 100644 index 0000000..5becc00 --- /dev/null +++ b/ai_context/tone_of_voice.md @@ -0,0 +1,8 @@ +# Tone of Voice +- Schreibe extrem authentisch, wie ein echter Mensch. +- Nutze Umgangssprache, wo es passt (z.B. "Mega", "Hammer Bild", "Stark!"). +- Mache die Kommentare super kurz, maximal 1 oder kurze 2 Sätze. +- Schreibe bevorzugt auf Deutsch (es sei denn, die Caption ist eindeutig englisch und verlangt danach, aber auch da ist D-Englisch oder kurzer Slang ok). +- Keine fÃļrmliche Sprache, kein "Sehr geehrte", kein "Viele GrÃŧße". +- Keine Hastags in Kommentaren! +- Maximal ein einziges Emoji am Ende. diff --git a/config-examples/blacklist.txt b/config-examples/blacklist.txt new file mode 100644 index 0000000..8e220c8 --- /dev/null +++ b/config-examples/blacklist.txt @@ -0,0 +1,2 @@ +username1 +username2 \ No newline at end of file diff --git a/config-examples/comments_list.txt b/config-examples/comments_list.txt new file mode 100644 index 0000000..c27c630 --- /dev/null +++ b/config-examples/comments_list.txt @@ -0,0 +1,15 @@ +%PHOTO +comment 1 for photo +comment 2 for photo +... +comment n for photo +%VIDEO +comment 1 for video +comment 2 for video +... +comment n for video +%CAROUSEL +comment 1 for carousel +comment 2 for carousel +... +comment n for carousel \ No newline at end of file diff --git a/config-examples/config.yml b/config-examples/config.yml new file mode 100644 index 0000000..39169a2 --- /dev/null +++ b/config-examples/config.yml @@ -0,0 +1,138 @@ +############################################################################## +# For more information on parameters, refer to: +# https://docs.gramaddict.org/#/configuration?id=configuration-file +# +# Note: be sure to comment out any parameters not used by adding a # in front +# AGAIN: YOU DON'T HAVE TO DELETE THE LINE, BUT ONLY COMMENT IT WITH A #! +############################################################################## +# General Configuration +############################################################################## + +username: myusername # you have to put your IG name here! +# device: put_your_device_id_there # 'adb devices' in the console to know it. It's needed only if you have more than 1 device connected +app-id: com.instagram.android +use-cloned-app: false +allow-untested-ig-version: false # Using an untested version of IG would cause unexpected behavior because some elements in the user interface may have been changed +screen-sleep: true +screen-record: false +speed-multiplier: 1 +debug: false +close-apps: false +kill-atx-agent: false +restart-atx-agent: false +disable-block-detection: false +disable-filters: false +dont-type: false +# scrape-to-file: scraped.txt +total-crashes-limit: 5 +count-app-crashes: false +shuffle-jobs: true +truncate-sources: 2-5 + +############################################################################## +# Actions +############################################################################## + +## Interaction (active jobs) +blogger-followers: [ username1, username2 ] +blogger-following: [ username1, username2 ] +blogger-post-likers: [ username1, username2 ] +blogger: [ username1, username2 ] +hashtag-likers-top: [ hashtag1, hashtag2 ] +hashtag-likers-recent: [ hashtag1, hashtag2 ] +hashtag-posts-top: [ hashtag1, hashtag2 ] +hashtag-posts-recent: [ hashtag1, hashtag2 ] +place-posts-top: [ place1, place2 ] +place-posts-recent: [ place1, place2 ] +place-likers-top: [ place1, place2 ] +place-likers-recent: [ place1, place2 ] +interact-from-file: [usernames1.txt 10-15, usernames2.txt 3] +posts-from-file: posts.txt +feed: 2-5 # is the number of likes you will give in feed + +## Special modifier for jobs and sources +watch-video-time: 15-35 +watch-photo-time: 3-4 +# can-reinteract-after: 48 # the amount of hours that have to pass from the last interaction +delete-interacted-users: true + +## Unfollow (unfollow jobs) +unfollow: 10-20 +unfollow-any: 10-20 +unfollow-non-followers: 10-20 +unfollow-any-non-followers: 10-20 +unfollow-any-followers: 10-20 +unfollow-from-file: [usernames1.txt 7-15, usernames2.txt 6] + +## Special modifier for unfollow jobs +sort-followers-newest-to-oldest: false +unfollow-delay: 15 + +## Remove followers (active jobs) +remove-followers-from-file: [remove1.txt 5-10, remove2.txt 6] + +## Special modifier for remove followers +delete-removed-followers: true + +## Post Processing +# analytics: false # no more supported +telegram-reports: false # for using telegram-reports you have also to configure telegram.yml in your account folder + +## Special actions +# pre-script: pre_script_path_here +# post-script: post_script_path_here + +############################################################################## +# Source Limits +############################################################################## + +interactions-count: 30-40 +likes-count: 1-2 +likes-percentage: 100 +stories-count: 1-2 +stories-percentage: 30-40 +carousel-count: 2-3 +carousel-percentage: 60-70 +max-comments-pro-user: 1-2 +# comment-percentage: 30-40 +# pm-percentage: 30-40 +interact-percentage: 30-40 +follow-percentage: 30-40 +follow-limit: 50 +skipped-list-limit: 10-15 +skipped-posts-limit: 5 +fling-when-skipped: 0 +min-following: 100 + +############################################################################## +# Total Limits Per Session +############################################################################## + +total-likes-limit: 120-150 +total-follows-limit: 40-50 +total-unfollows-limit: 40-50 +total-watches-limit: 120-150 +total-successful-interactions-limit: 120-150 +total-interactions-limit: 280-300 +total-comments-limit: 3-5 +total-pm-limit: 3-5 +total-scraped-limit: 100-150 + +############################################################################## +# Ending Session Conditions +############################################################################## + +end-if-likes-limit-reached: true +end-if-follows-limit-reached: false +end-if-watches-limit-reached: false +end-if-comments-limit-reached: false +end-if-pm-limit-reached: false + +############################################################################## +# Scheduling +############################################################################## + +working-hours: [10.15-16.40, 18.15-22.46] +time-delta: 10-15 +repeat: 280-320 +total-sessions: 1 # -1 or commented for infinite sessions diff --git a/config-examples/filters.yml b/config-examples/filters.yml new file mode 100644 index 0000000..79cea95 --- /dev/null +++ b/config-examples/filters.yml @@ -0,0 +1,63 @@ +############################################################################## +# For more information on filters, refer to: +# https://docs.gramaddict.org/#/configuration?id=available-filters +# +# Note: be sure to comment out any filter not used by adding a # in front +# AGAIN: YOU DON'T HAVE TO DELETE THE LINE, BUT ONLY COMMENT IT WITH A #! +############################################################################## + +## Filters on profile type +skip_if_private: false +skip_if_public: false +skip_business: true +skip_non_business: false +skip_following: true +skip_follower: true +skip_if_link_in_bio: true +follow_private_or_empty: false + +## Filters on profile stats +min_followers: 50 +max_followers: 2500 +min_followings: 50 +max_followings: 2500 +min_potency_ratio: 0.5 +max_potency_ratio: 5 +min_posts: 3 +mutual_friends: -1 # -1 for ignore that filter + +## Filters on biography and name +blacklist_words: [sex, link,] +mandatory_words: [cat, dogs,] +specific_alphabet: [LATIN, GREEK] +biography_language: [it, en] +biography_banned_language: [es, ch] + +## Filters for enabling comments +# Action specific +comment_hashtag_likers_top: true +comment_hashtag_likers_recent: true +comment_hashtag_posts_top: true +comment_hashtag_posts_recent: true +comment_place_likers_top: true +comment_place_likers_recent: true +comment_place_posts_top: true +comment_place_posts_recent: true +comment_blogger_followers: true +comment_blogger_following: true +comment_blogger_post_likers: true +comment_blogger: true +comment_interact_usernames: true +comment_interact_from_file: true +comment_feed: false +# Content specific +comment_photos: true +comment_videos: true +comment_carousels: true + +## Filters for sending PM +pm_to_private_or_empty: true + +## Filters on number of post likers +min_likers: 1 +max_likers: 1000 diff --git a/config-examples/pm_list.txt b/config-examples/pm_list.txt new file mode 100644 index 0000000..21f118e --- /dev/null +++ b/config-examples/pm_list.txt @@ -0,0 +1,4 @@ +private message 1 +private message 2 +... +private message n \ No newline at end of file diff --git a/config-examples/telegram.yml b/config-examples/telegram.yml new file mode 100644 index 0000000..06a3b34 --- /dev/null +++ b/config-examples/telegram.yml @@ -0,0 +1,6 @@ +# The complete guide can be found here: https://docs.gramaddict.org/#/configuration?id=telegram-reports +# telegram-api-token -> https://t.me/botfather to create your telegram bot account +# telegram-chat-id -> https://t.me/myidbot to know your chat-id where the bot will send reports + +telegram-api-token: your-api-token-here +telegram-chat-id: your-chat-id-here diff --git a/config-examples/whitelist.txt b/config-examples/whitelist.txt new file mode 100644 index 0000000..8e220c8 --- /dev/null +++ b/config-examples/whitelist.txt @@ -0,0 +1,2 @@ +username1 +username2 \ No newline at end of file diff --git a/extra/configs-loader/configs_loader.py b/extra/configs-loader/configs_loader.py new file mode 100644 index 0000000..440a141 --- /dev/null +++ b/extra/configs-loader/configs_loader.py @@ -0,0 +1,45 @@ +import logging +from enum import Enum, auto +from itertools import cycle +from subprocess import Popen + +import yaml + + +class Mode(Enum): + REPEAT = auto() + SINGLE = auto() + + +logger = logging.getLogger("configs-loader") +logging.basicConfig( + level=logging.INFO, + format="[%(asctime)s] %(name)-12s ==> %(message)s", + datefmt="%m/%d %H:%M:%S", +) + +mode = Mode.REPEAT + +if __name__ == "__main__": + bot_run = "gramaddict run --config".split(" ") + + def process_config(): + cur_conf = bot_run + [configs.get(config, {}).get("path", "")] + logger.info(f"Starting `{config}` - {configs[config].get('path')}") + with Popen(cur_conf, text=True, shell=True) as p: + p.wait() + + with open("configs-list.yml", "r") as stream: + try: + configs = yaml.safe_load(stream) + except yaml.YAMLError as exc: + logger.error(exc) + exit(1) + + if mode == Mode.REPEAT: + for config in cycle(configs): + process_config() + elif mode == Mode.SINGLE: + for config in configs: + process_config() + logger.info("Finish!") diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..8e6fec7 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,40 @@ +[build-system] +requires = ["flit_core >=3.2,<4"] +build-backend = "flit_core.buildapi" + +[project] +name = "GramAddict" +authors = [{ name = "GramAddict Team", email = "maintainers@gramaddict.org" }] +readme = "README.md" +classifiers = [ + "License :: Free for non-commercial use", + "Operating System :: OS Independent", + "Programming Language :: Python :: 3" +] +license = { file = "LICENSE" } +requires-python = ">=3.6" +dynamic = ["version", "description"] +dependencies = [ + "colorama==0.4.4", + "ConfigArgParse==1.5.3", + "PyYAML==6.0.1", + "uiautomator2==2.16.14", + "urllib3==1.26.18", + "emoji==1.6.1", + "langdetect==1.0.9", + "atomicwrites==1.4.0", + "spintax==1.0.4", + "requests~=2.31.0", + "packaging~=20.9" +] + +[project.optional-dependencies] +analytics = ["matplotlib==3.4.2"] +dev = ["flit", "pre-commit", "black", "flake8", "isort", "ruff", "pytest", "pytest-mock", "pytest-asyncio"] + +[project.urls] +Documentation = "https://docs.gramaddict.org/#/" +Source = "https://github.com/GramAddict/bot" + +[project.scripts] +gramaddict = "GramAddict.__main__:main" \ No newline at end of file diff --git a/pytest_anomalies_integration_err.txt b/pytest_anomalies_integration_err.txt new file mode 100644 index 0000000..bcb23a0 --- /dev/null +++ b/pytest_anomalies_integration_err.txt @@ -0,0 +1,807 @@ +============================= test session starts ============================== +platform darwin -- Python 3.9.6, pytest-8.3.5, pluggy-1.5.0 +rootdir: /Volumes/Alpha SSD/Coding/bot +configfile: pyproject.toml +plugins: asyncio-0.23.5, cov-7.1.0, anyio-3.7.1, mock-3.14.0, xdist-3.6.1 +asyncio: mode=strict +collected 152 items + +tests/anomalies/test_bot_flow_edge_cases.py ... [ 1%] +tests/anomalies/test_cognitive_edge_cases.py ... [ 3%] +tests/anomalies/test_fsd_recovery.py F [ 4%] +tests/anomalies/test_hardware_anomalies.py EEEE. [ 7%] +tests/anomalies/test_hardware_edge_cases.py .. [ 9%] +tests/anomalies/test_human_hesitation.py .. [ 10%] +tests/anomalies/test_llm_hallucination_recovery.py .. [ 11%] +tests/anomalies/test_nav_failure_tdd.py . [ 12%] +tests/anomalies/test_nav_graph_edge_cases.py ... [ 14%] +tests/anomalies/test_xml_dumps_fuzz.py s [ 15%] +tests/integration/test_ad_detection.py FFF [ 17%] +tests/integration/test_bot_flow_interaction.py ..........F.. [ 25%] +tests/integration/test_bot_flow_start.py F [ 26%] +tests/integration/test_cognitive_integration.py FF.F [ 28%] +tests/integration/test_cognitive_stack_audit.py ....... [ 33%] +tests/integration/test_darwin_engine.py .... [ 36%] +tests/integration/test_deep_engagement.py s.. [ 38%] +tests/integration/test_device_facade_full.py ........... [ 45%] +tests/integration/test_dm_loop.py .. [ 46%] +tests/integration/test_false_positive.py F [ 47%] +tests/integration/test_llm_provider_full.py ....... [ 51%] +tests/integration/test_q_nav_graph.py ... [ 53%] +tests/integration/test_qdrant_memory_full.py ............ [ 61%] +tests/integration/test_resonance_engine.py ....... [ 66%] +tests/integration/test_scenarios_fsd.py EE [ 67%] +tests/integration/test_swarm_protocol.py F... [ 70%] +tests/integration/test_telepathic_edge_cases.py ...... [ 74%] +tests/integration/test_telepathic_engine_extraction.py FFFFFEEFFFFFF [ 82%] +tests/integration/test_telepathic_engine_vlm.py ...................... [ 97%] +tests/integration/test_telepathic_keyword.py . [ 98%] +tests/integration/test_unfollow_loop.py ... [100%] + +==================================== ERRORS ==================================== +______________ ERROR at setup of test_slow_loading_post_recovery _______________ + + @pytest.fixture + def test_dumps(): + dumps = {} +> with open(DUMPS["organic"], "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/tests/fixtures/organic_post.xml' + +tests/anomalies/test_hardware_anomalies.py:39: FileNotFoundError +____________ ERROR at setup of test_wait_timeout_aborts_gracefully _____________ + + @pytest.fixture + def test_dumps(): + dumps = {} +> with open(DUMPS["organic"], "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/tests/fixtures/organic_post.xml' + +tests/anomalies/test_hardware_anomalies.py:39: FileNotFoundError +____________ ERROR at setup of test_empty_content_extraction_guard _____________ + + @pytest.fixture + def test_dumps(): + dumps = {} +> with open(DUMPS["organic"], "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/tests/fixtures/organic_post.xml' + +tests/anomalies/test_hardware_anomalies.py:39: FileNotFoundError +______________ ERROR at setup of test_missing_feed_markers_guard _______________ + + @pytest.fixture + def test_dumps(): + dumps = {} +> with open(DUMPS["organic"], "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/tests/fixtures/organic_post.xml' + +tests/anomalies/test_hardware_anomalies.py:39: FileNotFoundError +____________ ERROR at setup of test_full_mission_autopilot_sequence ____________ + + @pytest.fixture + def fsd_fixtures(): + def _load(name): + with open(os.path.join(FIX_DIR, name), "r") as f: + return f.read() + return { +> "organic": _load("organic_post.xml"), + "ad": _load("sponsored_reel.xml"), + "modal": _load("survey_modal.xml") + } + +tests/integration/test_scenarios_fsd.py:64: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'organic_post.xml' + + def _load(name): +> with open(os.path.join(FIX_DIR, name), "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/tests/fixtures/organic_post.xml' + +tests/integration/test_scenarios_fsd.py:61: FileNotFoundError +_________________ ERROR at setup of test_feed_loop_chaos_mode __________________ + + @pytest.fixture + def fsd_fixtures(): + def _load(name): + with open(os.path.join(FIX_DIR, name), "r") as f: + return f.read() + return { +> "organic": _load("organic_post.xml"), + "ad": _load("sponsored_reel.xml"), + "modal": _load("survey_modal.xml") + } + +tests/integration/test_scenarios_fsd.py:64: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'organic_post.xml' + + def _load(name): +> with open(os.path.join(FIX_DIR, name), "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/tests/fixtures/organic_post.xml' + +tests/integration/test_scenarios_fsd.py:61: FileNotFoundError +_ ERROR at setup of TestSafetyGuard.test_real_explore_fullscreen_container_rejected _ + +self = + + @pytest.fixture(autouse=True) + def setup_real_nodes(self): + """Pre-parse real XML nodes BEFORE any mocking happens.""" + engine = TelepathicEngine() +> explore_xml = load_fixture("explore_feed.xml") + +tests/integration/test_telepathic_engine_extraction.py:140: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'explore_feed.xml' + + def load_fixture(name: str) -> str: + """Load a real XML capture from tests/mock_data/""" + path = os.path.join(FIXTURE_DIR, name) +> with open(path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/integration/mock_data/explore_feed.xml' + +tests/integration/test_telepathic_engine_extraction.py:27: FileNotFoundError +------------------------------ Captured log setup ------------------------------ +WARNING GramAddict.core.qdrant_memory:qdrant_memory.py:35 Qdrant dimension mismatch for 'telepathic_engine_cache': collection has , expected 768. Recreating collection... +___ ERROR at setup of TestSafetyGuard.test_real_explore_like_button_accepted ___ + +self = + + @pytest.fixture(autouse=True) + def setup_real_nodes(self): + """Pre-parse real XML nodes BEFORE any mocking happens.""" + engine = TelepathicEngine() +> explore_xml = load_fixture("explore_feed.xml") + +tests/integration/test_telepathic_engine_extraction.py:140: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'explore_feed.xml' + + def load_fixture(name: str) -> str: + """Load a real XML capture from tests/mock_data/""" + path = os.path.join(FIXTURE_DIR, name) +> with open(path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/integration/mock_data/explore_feed.xml' + +tests/integration/test_telepathic_engine_extraction.py:27: FileNotFoundError +------------------------------ Captured log setup ------------------------------ +WARNING GramAddict.core.qdrant_memory:qdrant_memory.py:35 Qdrant dimension mismatch for 'telepathic_engine_cache': collection has , expected 768. Recreating collection... +=================================== FAILURES =================================== +___________________ test_fsd_handles_persistent_survey_modal ___________________ + + def test_fsd_handles_persistent_survey_modal(): + """ + Simulates a case where the bot gets stuck on a survey modal. + The FSD (Full Self Driving) anomaly handler should trigger, + detect that 'Back' didn't work, and engage TelepathicEngine + to find and tap the 'Not Now' or 'Dismiss' button. + """ + from GramAddict.core.bot_flow import _run_zero_latency_feed_loop + from GramAddict.core.telepathic_engine import TelepathicEngine + + device = MagicMock() + device.app_id = "com.instagram.android" + device._get_current_app.return_value = "com.instagram.android" + configs = ConfigMock() + + # Mock the TelepathicEngine singleton behavior entirely + mock_telepathic = MagicMock() + mock_telepathic.find_best_node.return_value = {"x": 500, "y": 1400, "semantic": "Not Now"} + mock_telepathic._extract_semantic_nodes.return_value = [{"x": 10}] + + dopamine = MagicMock() + dopamine.is_app_session_over.side_effect = [False, False, True] # Run twice, then exit + dopamine.wants_to_change_feed.return_value = False + dopamine.wants_to_doomscroll.return_value = False + + ai = MagicMock() + ai.get_sleep_modifier.return_value = 1.0 + cognitive_stack = {"dopamine": dopamine, "growth_brain": None, "active_inference": ai, "telepathic": mock_telepathic} + + # Load the mock survey modal UI + xml_path = os.path.join(FIXTURE_DIR, "survey_modal.xml") +> with open(xml_path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/tests/fixtures/survey_modal.xml' + +tests/anomalies/test_fsd_recovery.py:46: FileNotFoundError +________________ test_real_sponsored_reel_flexcode_is_detected _________________ + + def test_real_sponsored_reel_flexcode_is_detected(): + """ + Test: The manual_interrupt dump is a sponsored Reel (flexcode_systems). + _detect_ad_structural MUST return True. + """ + xml_path = os.path.join(FIX_DIR, "sponsored_reel.xml") +> with open(xml_path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/tests/fixtures/sponsored_reel.xml' + +tests/integration/test_ad_detection.py:13: FileNotFoundError +___________________________ test_normal_post_not_ad ____________________________ + + def test_normal_post_not_ad(): + """ + Test: The manual_interrupt dump is a normal post. + _detect_ad_structural MUST return False to avoid false positives. + """ + xml_path = os.path.join(FIX_DIR, "organic_post.xml") +> with open(xml_path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/tests/fixtures/organic_post.xml' + +tests/integration/test_ad_detection.py:24: FileNotFoundError +_____________________ test_peugeot_carousel_ad_is_detected _____________________ + + def test_peugeot_carousel_ad_is_detected(): + """ + Test: The 'peugeot.deutschland' carousel ad from manual_interrupt dump. + _detect_ad_structural MUST return True. + """ + xml_path = os.path.join(FIX_DIR, "peugeot_ad.xml") +> with open(xml_path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/tests/fixtures/peugeot_ad.xml' + +tests/integration/test_ad_detection.py:36: FileNotFoundError +___________________________ test_start_bot_interrupt ___________________________ + + def test_start_bot_interrupt(): + from GramAddict.core.bot_flow import start_bot + + # Mock all the heavy initialization + with patch('GramAddict.core.bot_flow.Config') as MockConfig, \ + patch('GramAddict.core.bot_flow.configure_logger'), \ + patch('GramAddict.core.bot_flow.check_if_updated'), \ + patch('GramAddict.core.benchmark_guard.check_model_benchmarks'), \ + patch('GramAddict.core.llm_provider.log_openrouter_burn'), \ + patch('GramAddict.core.bot_flow.create_device') as mock_create_device, \ + patch('GramAddict.core.bot_flow.set_time_delta') as mock_time_delta, \ + patch('GramAddict.core.bot_flow.SessionState') as MockSession, \ + patch('GramAddict.core.bot_flow.open_instagram', side_effect=KeyboardInterrupt()), \ + patch('GramAddict.core.bot_flow.dump_ui_state') as mock_dump: + + MockConfig.return_value.args.feed = True + MockConfig.return_value.args.explore = False + MockConfig.return_value.args.reels = False + MockConfig.return_value.args.stories = False + MockConfig.return_value.args.working_hours = [10, 20] + MockConfig.return_value.args.time_delta_session = 30 + + MockSession.inside_working_hours.return_value = (True, 0) + + with pytest.raises(KeyboardInterrupt): +> start_bot(username="test", device_id="123") +E Failed: DID NOT RAISE + +tests/integration/test_bot_flow_interaction.py:190: Failed +----------------------------- Captured stdout call ----------------------------- + +================================================== +🤖 MANUAL E2E DUMP CAPTURE SEQUENCE +================================================== +Please follow the instructions below to capture the required fixtures. +If an IG update changed the layout, you can navigate there naturally. +================================================== + + +👉 1. COMMENT SHEET: +Open Instagram, scroll to any post on the HomeFeed, and open the comment section. +When the comment sheet is fully visible, press ENTER to capture... +------------------------------ Captured log call ------------------------------- +ERROR GramAddict.core.dump_capturer:dump_capturer.py:105 đŸ’Ĩ Capture Sequence crashed: pytest: reading from stdin while output is captured! Consider using `-s`. +Traceback (most recent call last): + File "/Volumes/Alpha SSD/Coding/bot/GramAddict/core/dump_capturer.py", line 43, in capture_all + input("\n👉 1. COMMENT SHEET:\nOpen Instagram, scroll to any post on the HomeFeed, and open the comment section.\nWhen the comment sheet is fully visible, press ENTER to capture...") + File "/Users/marcmintel/Library/Python/3.9/lib/python/site-packages/_pytest/capture.py", line 227, in read + raise OSError( +OSError: pytest: reading from stdin while output is captured! Consider using `-s`. +__________________________ test_start_bot_normal_flow __________________________ + +MockConfig = +mock_logger = +mock_update = +mock_benchmark = +mock_burn = +mock_create_device = +mock_time_delta = +MockSession = +mock_open_ig = +mock_ig_version = +mock_close_ig = +mock_sleep = +mock_dump = +mock_telepathic = +mock_nav = +mock_zero = +mock_dopamine_class = +mock_resonance = +mock_growth = +mock_crm = +mock_radome = +mock_dojo = +mock_run_feed = + + @patch('GramAddict.core.bot_flow._run_zero_latency_feed_loop', return_value="SESSION_OVER") + @patch('GramAddict.core.bot_flow.DojoEngine') + @patch('GramAddict.core.bot_flow.HoneypotRadome') + @patch('GramAddict.core.bot_flow.ParasocialCRMDB') + @patch('GramAddict.core.bot_flow.GrowthBrain') + @patch('GramAddict.core.bot_flow.ResonanceEngine') + @patch('GramAddict.core.bot_flow.DopamineEngine') + @patch('GramAddict.core.bot_flow.ZeroLatencyEngine') + @patch('GramAddict.core.bot_flow.QNavGraph') + @patch('GramAddict.core.bot_flow.TelepathicEngine') + @patch('GramAddict.core.bot_flow.dump_ui_state') + @patch('GramAddict.core.bot_flow.random_sleep') + @patch('GramAddict.core.bot_flow.close_instagram') + @patch('GramAddict.core.bot_flow.get_instagram_version', return_value="1.0") + @patch('GramAddict.core.bot_flow.open_instagram', return_value=True) + @patch('GramAddict.core.bot_flow.SessionState') + @patch('GramAddict.core.bot_flow.set_time_delta') + @patch('GramAddict.core.bot_flow.create_device') + @patch('GramAddict.core.llm_provider.log_openrouter_burn') + @patch('GramAddict.core.benchmark_guard.check_model_benchmarks') + @patch('GramAddict.core.bot_flow.check_if_updated') + @patch('GramAddict.core.bot_flow.configure_logger') + @patch('GramAddict.core.bot_flow.Config') + def test_start_bot_normal_flow(MockConfig, mock_logger, mock_update, mock_benchmark, mock_burn, + mock_create_device, mock_time_delta, MockSession, mock_open_ig, mock_ig_version, + mock_close_ig, mock_sleep, mock_dump, mock_telepathic, mock_nav, mock_zero, + mock_dopamine_class, mock_resonance, mock_growth, mock_crm, mock_radome, mock_dojo, mock_run_feed): + + MockConfig.return_value.args.feed = True + MockConfig.return_value.args.explore = False + MockConfig.return_value.args.reels = True + MockConfig.return_value.args.stories = False + MockConfig.return_value.args.working_hours = [10, 20] + MockConfig.return_value.args.time_delta_session = 30 + + MockSession.inside_working_hours.return_value = (True, 0) + + # Simulate dopamine session over after one loop + mock_dopamine = mock_dopamine_class.return_value + mock_dopamine.is_app_session_over.side_effect = [False, True] + mock_dopamine.boredom = 10.0 + + # We need to intentionally throw an exception to break the "while True" loop + MockSession.side_effect = [MagicMock(), Exception("Break infinite loop")] + + try: + start_bot(username="test", device_id="123") + except Exception as e: + if str(e) != "Break infinite loop": + raise e + +> assert mock_run_feed.called +E AssertionError: assert False +E + where False = .called + +tests/integration/test_bot_flow_start.py:56: AssertionError +----------------------------- Captured stdout call ----------------------------- + +================================================== +🤖 MANUAL E2E DUMP CAPTURE SEQUENCE +================================================== +Please follow the instructions below to capture the required fixtures. +If an IG update changed the layout, you can navigate there naturally. +================================================== + + +👉 1. COMMENT SHEET: +Open Instagram, scroll to any post on the HomeFeed, and open the comment section. +When the comment sheet is fully visible, press ENTER to capture... +------------------------------ Captured log call ------------------------------- +ERROR GramAddict.core.dump_capturer:dump_capturer.py:105 đŸ’Ĩ Capture Sequence crashed: pytest: reading from stdin while output is captured! Consider using `-s`. +Traceback (most recent call last): + File "/Volumes/Alpha SSD/Coding/bot/GramAddict/core/dump_capturer.py", line 43, in capture_all + input("\n👉 1. COMMENT SHEET:\nOpen Instagram, scroll to any post on the HomeFeed, and open the comment section.\nWhen the comment sheet is fully visible, press ENTER to capture...") + File "/Users/marcmintel/Library/Python/3.9/lib/python/site-packages/_pytest/capture.py", line 227, in read + raise OSError( +OSError: pytest: reading from stdin while output is captured! Consider using `-s`. +_____________________ test_full_content_to_resonance_flow ______________________ + +mock_engines = (, ) + + def test_full_content_to_resonance_flow(mock_engines): + """ + REALITY CHECK: Tests the flow from RAW XML -> EXTRACED CONTENT -> RESONANCE SCORE. + Using 'dump.xml' which contains an organic post and an ad. + """ + resonance, _ = mock_engines + +> with open(DUMPS["organic"], "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/tests/fixtures/organic_post.xml' + +tests/integration/test_cognitive_integration.py:51: FileNotFoundError +________________________ test_ad_detection_integration _________________________ + + def test_ad_detection_integration(): + """Verify that _detect_ad_structural works on the actual ad_dump.xml.""" + from GramAddict.core.bot_flow import _detect_ad_structural + +> with open(DUMPS["ad"], "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/tests/fixtures/peugeot_ad.xml' + +tests/integration/test_cognitive_integration.py:73: FileNotFoundError +__________________________ test_extract_explore_reel ___________________________ + + def test_extract_explore_reel(): + """Verify extraction logic works on the Explore Grid/Reels dump.""" +> with open(DUMPS["explore"], "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/tests/mock_data/explore_feed.xml' + +tests/integration/test_cognitive_integration.py:98: FileNotFoundError +_______________________ test_real_normal_post_is_not_ad ________________________ + + def test_real_normal_post_is_not_ad(): + """ + Test: Ensures the ad detector correctly ignores a standard organic post. + """ + xml_path = os.path.join(FIX_DIR, "organic_post.xml") +> with open(xml_path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/tests/fixtures/organic_post.xml' + +tests/integration/test_false_positive.py:12: FileNotFoundError +_____________________________ test_emit_pheromone ______________________________ + +swarm = + + def test_emit_pheromone(swarm): + """Verify that emitting a pheromone calls Qdrant upsert with correct payload.""" + with patch("GramAddict.core.qdrant_memory.QdrantBase.is_connected", new_callable=PropertyMock, return_value=True): + path_hash = "some_ui_path_hash" + outcome = "success" + + swarm.emit_pheromone(path_hash, outcome) + + # Check if upsert was called with the expected payload + swarm.client.upsert.assert_called_once() + args, kwargs = swarm.client.upsert.call_args + points = kwargs.get('points') +> assert points[0].payload['path_hash'] == path_hash +E AssertionError: assert == 'some_ui_path_hash' + +tests/integration/test_swarm_protocol.py:22: AssertionError +------------------------------ Captured log setup ------------------------------ +WARNING GramAddict.core.qdrant_memory:qdrant_memory.py:35 Qdrant dimension mismatch for 'gramaddict_swarm_pheromones': collection has , expected 4. Recreating collection... +____________ TestNodeExtraction.test_home_feed_extracts_like_button ____________ + +self = + + def test_home_feed_extracts_like_button(self): + """ + In a real Home Feed dump, the parser MUST find the Like button node + with resource-id 'row_feed_button_like'. + """ + engine = TelepathicEngine() +> xml = load_fixture("home_feed_with_ad.xml") + +tests/integration/test_telepathic_engine_extraction.py:43: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'home_feed_with_ad.xml' + + def load_fixture(name: str) -> str: + """Load a real XML capture from tests/mock_data/""" + path = os.path.join(FIXTURE_DIR, name) +> with open(path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/integration/mock_data/home_feed_with_ad.xml' + +tests/integration/test_telepathic_engine_extraction.py:27: FileNotFoundError +------------------------------ Captured log call ------------------------------- +WARNING GramAddict.core.qdrant_memory:qdrant_memory.py:35 Qdrant dimension mismatch for 'telepathic_engine_cache': collection has , expected 768. Recreating collection... +______________ TestNodeExtraction.test_home_feed_extracts_tab_bar ______________ + +self = + + def test_home_feed_extracts_tab_bar(self): + """ + The parser must find the bottom tab bar items (Home, Reels, Search, Profile). + These are critical for navigation. + """ + engine = TelepathicEngine() +> xml = load_fixture("home_feed_with_ad.xml") + +tests/integration/test_telepathic_engine_extraction.py:66: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'home_feed_with_ad.xml' + + def load_fixture(name: str) -> str: + """Load a real XML capture from tests/mock_data/""" + path = os.path.join(FIXTURE_DIR, name) +> with open(path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/integration/mock_data/home_feed_with_ad.xml' + +tests/integration/test_telepathic_engine_extraction.py:27: FileNotFoundError +------------------------------ Captured log call ------------------------------- +WARNING GramAddict.core.qdrant_memory:qdrant_memory.py:35 Qdrant dimension mismatch for 'telepathic_engine_cache': collection has , expected 768. Recreating collection... +__________ TestNodeExtraction.test_home_feed_node_count_is_realistic ___________ + +self = + + def test_home_feed_node_count_is_realistic(self): + """ + A real Instagram home feed XML produces 20-40 interactive nodes. + If we get <10 or >100, the parser is broken. + """ + engine = TelepathicEngine() +> xml = load_fixture("home_feed_with_ad.xml") + +tests/integration/test_telepathic_engine_extraction.py:80: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'home_feed_with_ad.xml' + + def load_fixture(name: str) -> str: + """Load a real XML capture from tests/mock_data/""" + path = os.path.join(FIXTURE_DIR, name) +> with open(path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/integration/mock_data/home_feed_with_ad.xml' + +tests/integration/test_telepathic_engine_extraction.py:27: FileNotFoundError +------------------------------ Captured log call ------------------------------- +WARNING GramAddict.core.qdrant_memory:qdrant_memory.py:35 Qdrant dimension mismatch for 'telepathic_engine_cache': collection has , expected 768. Recreating collection... +__________ TestNodeExtraction.test_explore_feed_extracts_like_button ___________ + +self = + + def test_explore_feed_extracts_like_button(self): + """ + In the real Explore/Reels feed, the Like button has id 'like_button' + and description 'Like'. The parser must find it. + """ + engine = TelepathicEngine() +> xml = load_fixture("explore_feed.xml") + +tests/integration/test_telepathic_engine_extraction.py:94: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'explore_feed.xml' + + def load_fixture(name: str) -> str: + """Load a real XML capture from tests/mock_data/""" + path = os.path.join(FIXTURE_DIR, name) +> with open(path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/integration/mock_data/explore_feed.xml' + +tests/integration/test_telepathic_engine_extraction.py:27: FileNotFoundError +------------------------------ Captured log call ------------------------------- +WARNING GramAddict.core.qdrant_memory:qdrant_memory.py:35 Qdrant dimension mismatch for 'telepathic_engine_cache': collection has , expected 768. Recreating collection... +________ TestNodeExtraction.test_explore_feed_has_fullscreen_containers ________ + +self = + + def test_explore_feed_has_fullscreen_containers(self): + """ + Verify that the parser extracts the fullscreen containers + (swipeable_nav_view_pager_inner_recycler_view, clips_viewer_view_pager) + so that the Safety Guard has something to reject. + """ + engine = TelepathicEngine() +> xml = load_fixture("explore_feed.xml") + +tests/integration/test_telepathic_engine_extraction.py:112: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'explore_feed.xml' + + def load_fixture(name: str) -> str: + """Load a real XML capture from tests/mock_data/""" + path = os.path.join(FIXTURE_DIR, name) +> with open(path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/integration/mock_data/explore_feed.xml' + +tests/integration/test_telepathic_engine_extraction.py:27: FileNotFoundError +------------------------------ Captured log call ------------------------------- +WARNING GramAddict.core.qdrant_memory:qdrant_memory.py:35 Qdrant dimension mismatch for 'telepathic_engine_cache': collection has , expected 768. Recreating collection... +_______________ TestAdDetection.test_real_explore_feed_is_not_ad _______________ + +self = + + def test_real_explore_feed_is_not_ad(self): + """ + The explore_feed.xml is a real Reel without any ad markers. + It should NOT be flagged. + """ + from GramAddict.core.bot_flow import _detect_ad_structural + +> xml = load_fixture("explore_feed.xml") + +tests/integration/test_telepathic_engine_extraction.py:241: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'explore_feed.xml' + + def load_fixture(name: str) -> str: + """Load a real XML capture from tests/mock_data/""" + path = os.path.join(FIXTURE_DIR, name) +> with open(path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/integration/mock_data/explore_feed.xml' + +tests/integration/test_telepathic_engine_extraction.py:27: FileNotFoundError +_______________ TestFeedMarkers.test_real_home_feed_has_markers ________________ + +self = + + def test_real_home_feed_has_markers(self): + """The real home feed XML must match our feed markers.""" + from GramAddict.core.bot_flow import FEED_MARKERS + +> xml = load_fixture("home_feed_with_ad.xml") + +tests/integration/test_telepathic_engine_extraction.py:256: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'home_feed_with_ad.xml' + + def load_fixture(name: str) -> str: + """Load a real XML capture from tests/mock_data/""" + path = os.path.join(FIXTURE_DIR, name) +> with open(path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/integration/mock_data/home_feed_with_ad.xml' + +tests/integration/test_telepathic_engine_extraction.py:27: FileNotFoundError +______________ TestFeedMarkers.test_real_explore_feed_has_markers ______________ + +self = + + def test_real_explore_feed_has_markers(self): + """The real explore feed XML must match our feed markers.""" + from GramAddict.core.bot_flow import FEED_MARKERS + +> xml = load_fixture("explore_feed.xml") + +tests/integration/test_telepathic_engine_extraction.py:267: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'explore_feed.xml' + + def load_fixture(name: str) -> str: + """Load a real XML capture from tests/mock_data/""" + path = os.path.join(FIXTURE_DIR, name) +> with open(path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/integration/mock_data/explore_feed.xml' + +tests/integration/test_telepathic_engine_extraction.py:27: FileNotFoundError +______ TestTelepathicResolutionCascade.test_keyword_fast_path_bypasses_ai ______ + +self = +mock_get_embedding = +mock_vlm = + + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('GramAddict.core.qdrant_memory.QdrantBase._get_embedding') + def test_keyword_fast_path_bypasses_ai(self, mock_get_embedding, mock_vlm): + """ + A direct keyword match (like 'tap like button') MUST be resolved by Stage 1.5. + It must never reach the Embedding (Stage 2) or VLM (Stage 3). + """ + from GramAddict.core.telepathic_engine import TelepathicEngine + engine = TelepathicEngine() + engine._embedding_cache.clear() + engine._intent_cache.clear() + + # home_feed_with_ad.xml contains standard UI elements +> xml_content = load_fixture("home_feed_with_ad.xml") + +tests/integration/test_telepathic_engine_extraction.py:294: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'home_feed_with_ad.xml' + + def load_fixture(name: str) -> str: + """Load a real XML capture from tests/mock_data/""" + path = os.path.join(FIXTURE_DIR, name) +> with open(path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/integration/mock_data/home_feed_with_ad.xml' + +tests/integration/test_telepathic_engine_extraction.py:27: FileNotFoundError +------------------------------ Captured log call ------------------------------- +WARNING GramAddict.core.qdrant_memory:qdrant_memory.py:35 Qdrant dimension mismatch for 'telepathic_engine_cache': collection has , expected 768. Recreating collection... +_ TestTelepathicResolutionCascade.test_embedding_fallback_bypasses_vlm_if_confident _ + +self = +mock_get_embedding = +mock_vlm = + + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('GramAddict.core.qdrant_memory.QdrantBase._get_embedding') + def test_embedding_fallback_bypasses_vlm_if_confident(self, mock_get_embedding, mock_vlm): + """ + If we ask something without an exact keyword match, it should fail Stage 1.5, + hit Stage 2 (Embeddings), and if confident enough, avoid Stage 3 (VLM). + """ + from GramAddict.core.telepathic_engine import TelepathicEngine + engine = TelepathicEngine() + engine._embedding_cache.clear() + engine._intent_cache.clear() + +> xml_content = load_fixture("home_feed_with_ad.xml") + +tests/integration/test_telepathic_engine_extraction.py:318: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'home_feed_with_ad.xml' + + def load_fixture(name: str) -> str: + """Load a real XML capture from tests/mock_data/""" + path = os.path.join(FIXTURE_DIR, name) +> with open(path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/integration/mock_data/home_feed_with_ad.xml' + +tests/integration/test_telepathic_engine_extraction.py:27: FileNotFoundError +------------------------------ Captured log call ------------------------------- +WARNING GramAddict.core.qdrant_memory:qdrant_memory.py:35 Qdrant dimension mismatch for 'telepathic_engine_cache': collection has , expected 768. Recreating collection... +_ TestTelepathicResolutionCascade.test_vlm_fallback_triggered_on_low_confidence _ + +self = +mock_get_embedding = +mock_vlm = + + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('GramAddict.core.qdrant_memory.QdrantBase._get_embedding') + def test_vlm_fallback_triggered_on_low_confidence(self, mock_get_embedding, mock_vlm): + """ + If Embeddings fail to find a confident match (< 0.82), it must trigger + the Stage 3 VLM fallback. + """ + from GramAddict.core.telepathic_engine import TelepathicEngine + engine = TelepathicEngine() + engine._embedding_cache.clear() + engine._intent_cache.clear() + +> xml_content = load_fixture("home_feed_with_ad.xml") + +tests/integration/test_telepathic_engine_extraction.py:353: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'home_feed_with_ad.xml' + + def load_fixture(name: str) -> str: + """Load a real XML capture from tests/mock_data/""" + path = os.path.join(FIXTURE_DIR, name) +> with open(path, "r") as f: +E FileNotFoundError: [Errno 2] No such file or directory: '/Volumes/Alpha SSD/Coding/bot/tests/integration/mock_data/home_feed_with_ad.xml' + +tests/integration/test_telepathic_engine_extraction.py:27: FileNotFoundError +------------------------------ Captured log call ------------------------------- +WARNING GramAddict.core.qdrant_memory:qdrant_memory.py:35 Qdrant dimension mismatch for 'telepathic_engine_cache': collection has , expected 768. Recreating collection... +=============================== warnings summary =============================== +../../../../Users/marcmintel/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:35 + /Users/marcmintel/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:35: NotOpenSSLWarning: urllib3 v2 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020 + warnings.warn( + +-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html +=========================== short test summary info ============================ +FAILED tests/anomalies/test_fsd_recovery.py::test_fsd_handles_persistent_survey_modal +FAILED tests/integration/test_ad_detection.py::test_real_sponsored_reel_flexcode_is_detected +FAILED tests/integration/test_ad_detection.py::test_normal_post_not_ad - File... +FAILED tests/integration/test_ad_detection.py::test_peugeot_carousel_ad_is_detected +FAILED tests/integration/test_bot_flow_interaction.py::test_start_bot_interrupt +FAILED tests/integration/test_bot_flow_start.py::test_start_bot_normal_flow +FAILED tests/integration/test_cognitive_integration.py::test_full_content_to_resonance_flow +FAILED tests/integration/test_cognitive_integration.py::test_ad_detection_integration +FAILED tests/integration/test_cognitive_integration.py::test_extract_explore_reel +FAILED tests/integration/test_false_positive.py::test_real_normal_post_is_not_ad +FAILED tests/integration/test_swarm_protocol.py::test_emit_pheromone - Assert... +FAILED tests/integration/test_telepathic_engine_extraction.py::TestNodeExtraction::test_home_feed_extracts_like_button +FAILED tests/integration/test_telepathic_engine_extraction.py::TestNodeExtraction::test_home_feed_extracts_tab_bar +FAILED tests/integration/test_telepathic_engine_extraction.py::TestNodeExtraction::test_home_feed_node_count_is_realistic +FAILED tests/integration/test_telepathic_engine_extraction.py::TestNodeExtraction::test_explore_feed_extracts_like_button +FAILED tests/integration/test_telepathic_engine_extraction.py::TestNodeExtraction::test_explore_feed_has_fullscreen_containers +FAILED tests/integration/test_telepathic_engine_extraction.py::TestAdDetection::test_real_explore_feed_is_not_ad +FAILED tests/integration/test_telepathic_engine_extraction.py::TestFeedMarkers::test_real_home_feed_has_markers +FAILED tests/integration/test_telepathic_engine_extraction.py::TestFeedMarkers::test_real_explore_feed_has_markers +FAILED tests/integration/test_telepathic_engine_extraction.py::TestTelepathicResolutionCascade::test_keyword_fast_path_bypasses_ai +FAILED tests/integration/test_telepathic_engine_extraction.py::TestTelepathicResolutionCascade::test_embedding_fallback_bypasses_vlm_if_confident +FAILED tests/integration/test_telepathic_engine_extraction.py::TestTelepathicResolutionCascade::test_vlm_fallback_triggered_on_low_confidence +ERROR tests/anomalies/test_hardware_anomalies.py::test_slow_loading_post_recovery +ERROR tests/anomalies/test_hardware_anomalies.py::test_wait_timeout_aborts_gracefully +ERROR tests/anomalies/test_hardware_anomalies.py::test_empty_content_extraction_guard +ERROR tests/anomalies/test_hardware_anomalies.py::test_missing_feed_markers_guard +ERROR tests/integration/test_scenarios_fsd.py::test_full_mission_autopilot_sequence +ERROR tests/integration/test_scenarios_fsd.py::test_feed_loop_chaos_mode - Fi... +ERROR tests/integration/test_telepathic_engine_extraction.py::TestSafetyGuard::test_real_explore_fullscreen_container_rejected +ERROR tests/integration/test_telepathic_engine_extraction.py::TestSafetyGuard::test_real_explore_like_button_accepted +== 22 failed, 120 passed, 2 skipped, 1 warning, 8 errors in 76.34s (0:01:16) === diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..6022010 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,13 @@ +colorama==0.4.4 +ConfigArgParse==1.7 +PyYAML==6.0.1 +uiautomator2>=3.0.0 +urllib3>=2.0.0 +emoji==2.12.1 +langdetect==1.0.9 +atomicwrites==1.4.1 +spintax==1.0.4 +requests>=2.31.0 +packaging>=23.0 +python-dotenv==1.0.1 +qdrant-client>=1.7.0 diff --git a/res/demo.gif b/res/demo.gif new file mode 100644 index 0000000..d801bb0 Binary files /dev/null and b/res/demo.gif differ diff --git a/res/discord.png b/res/discord.png new file mode 100644 index 0000000..8841962 Binary files /dev/null and b/res/discord.png differ diff --git a/res/logo.png b/res/logo.png new file mode 100644 index 0000000..aab48fa Binary files /dev/null and b/res/logo.png differ diff --git a/res/telegram-reports.png b/res/telegram-reports.png new file mode 100644 index 0000000..ed1fe45 Binary files /dev/null and b/res/telegram-reports.png differ diff --git a/res/telegram.png b/res/telegram.png new file mode 100644 index 0000000..9cda34c Binary files /dev/null and b/res/telegram.png differ diff --git a/run.py b/run.py new file mode 100644 index 0000000..3c18e57 --- /dev/null +++ b/run.py @@ -0,0 +1,9 @@ +import sys +import GramAddict + +if __name__ == "__main__": + try: + GramAddict.run() + except KeyboardInterrupt: + print("\n\nGracefully exiting due to KeyboardInterrupt (Ctrl+C).") + sys.exit(0) diff --git a/scripts/benchmark_models.py b/scripts/benchmark_models.py new file mode 100644 index 0000000..f180fe1 --- /dev/null +++ b/scripts/benchmark_models.py @@ -0,0 +1,182 @@ +import os +import sys +import json +import time +import argparse +from datetime import datetime + +# Add root project path so we can import internal modules safely +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from GramAddict.core.llm_provider import query_telepathic_llm + +BENCHMARKS_FILE = os.path.join(os.path.dirname(os.path.dirname(__file__)), "GramAddict/core/llm_benchmarks.json") +SCENARIOS_FILE = os.path.join(os.path.dirname(os.path.dirname(__file__)), "GramAddict/core/benchmark_scenarios.json") + +def load_json(path): + if os.path.exists(path): + try: + with open(path, "r") as f: + return json.load(f) + except Exception: + return None + return None + +def save_json(path, data): + with open(path, "w") as f: + json.dump(data, f, indent=4) + +def normalize_scores(db): + if not db.get("models"): + return db + + # 1. Find the highest raw score across all models + max_raw = 0 + leader_model = None + + for name, data in db["models"].items(): + raw = data.get("raw_score", 0) + if raw > max_raw: + max_raw = raw + leader_model = name + elif raw == max_raw and max_raw > 0: + # Tie-breaker: Latency + current_lat = data.get("latency_ms", 99999) + leader_lat = db["models"][leader_model].get("latency_ms", 99999) + if current_lat < leader_lat: + leader_model = name + + if max_raw == 0: + return db + + # 2. Update relative performance + for name, data in db["models"].items(): + raw = data.get("raw_score", 0) + data["relative_performance_pct"] = round((raw / max_raw) * 100, 1) + data["is_leader"] = (name == leader_model) + + return db + +def benchmark_model(model_name: str, url: str, force: bool = False): + db = load_json(BENCHMARKS_FILE) or {"models": {}} + scenarios_data = load_json(SCENARIOS_FILE) + if not scenarios_data: + print("❌ Scenarios file missing!") + return + + if not force and model_name in db.get("models", {}): + pct = db["models"][model_name].get("relative_performance_pct", "N/A") + print(f"Typical execution skip for {model_name} (Rel: {pct}%). Use --force.") + return + + print(f"🚀 [Competitive Benchmarking] Model: {model_name}") + + total_raw = 0 + total_latency = 0 + results_detail = {} + + blank_b64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=" + system_prompt = ( + "You identify which UI element to tap on an Android screen. " + "Output ONLY valid JSON: {\"index\": number, \"reason\": \"brief reason\"}" + ) + + for scenario in scenarios_data["scenarios"]: + print(f"--- Running: {scenario['name']} ---") + + user_prompt = ( + f"Which element should I tap to: {scenario['task']}\n\n" + f"Elements:\n{json.dumps(scenario['nodes'], indent=1)}\n\n" + "Rules:\n" + "- Pick the SMALLEST, most specific button or icon\n" + "- NEVER pick large containers\n" + "Return: {\"index\": number, \"reason\": \"...\"}" + ) + + start_time = time.time() + try: + resp_str = query_telepathic_llm(model_name, url, system_prompt, user_prompt) + latency = int((time.time() - start_time) * 1000) + total_latency += latency + except Exception as e: + print(f" ❌ API Request failed for scenario {scenario['id']}: {e}") + continue + + raw_points = 0 + try: + clean = resp_str.strip() + if clean.startswith("```json"): clean = clean[7:] + if clean.endswith("```"): clean = clean[:-3] + data = json.loads(clean) + + # Points for structural adherence + if "index" in data and "reason" in data: + raw_points += 40 + + # Points for correctness + if data["index"] == scenario["target_index"]: + raw_points += 60 + print(f" ✅ Correct index ({data['index']}).") + else: + print(f" ❌ Wrong index ({data['index']}). Target was {scenario['target_index']}.") + else: + print(" ❌ JSON missing fields.") + except Exception: + print(" ❌ JSON Parsing failed.") + + results_detail[scenario["id"]] = raw_points + total_raw += raw_points + + print(f"\n📊 Total Raw Score for {model_name}: {total_raw}") + + if model_name not in db["models"]: + db["models"][model_name] = {} + + db["models"][model_name].update({ + "raw_score": total_raw, + "latency_ms": total_latency // len(scenarios_data["scenarios"]), + "last_tested": datetime.utcnow().isoformat() + "Z", + "details": results_detail + }) + + # Recalculate relative scores across all models + db = normalize_scores(db) + save_json(BENCHMARKS_FILE, db) + + leader_name = [n for n, d in db["models"].items() if d.get("is_leader")][0] + rel_pct = db["models"][model_name]["relative_performance_pct"] + + print(f"🏆 Current Leader: {leader_name}") + print(f"✨ Relative Performance for {model_name}: {rel_pct}%") + +if __name__ == "__main__": + from GramAddict.core.config import Config + + parser = argparse.ArgumentParser(description="Competitive Benchmark for Singularity", add_help=False) + parser.add_argument("--config", type=str, help="Bot config file") + parser.add_argument("--model", type=str, help="Explicit model name") + parser.add_argument("--url", type=str, help="Explicit endpoint URL") + parser.add_argument("--force", action="store_true", help="Force re-testing") + + args, unknown = parser.parse_known_args() + + models_to_test = [] + + if args.model and args.url: + models_to_test.append((args.model, args.url)) + elif args.config: + configs = Config(first_run=True, config=args.config) + configs.parse_args() + + for attr, pref in [("ai_telepathic_model", "ai_telepathic_url"), ("ai_model", "ai_model_url"), ("ai_condenser_model", "ai_condenser_url")]: + m = getattr(configs.args, attr, None) + u = getattr(configs.args, pref, "https://openrouter.ai/api/v1/chat/completions") + if m: + models_to_test.append((m, u)) + else: + print("❌ Syntax: --config test_config.yml or --model x --url y") + sys.exit(1) + + for m, u in set(models_to_test): + benchmark_model(m, u, args.force) + time.sleep(1) diff --git a/test_config.yml b/test_config.yml new file mode 100644 index 0000000..60f4a5c --- /dev/null +++ b/test_config.yml @@ -0,0 +1,59 @@ +username: + - marisaundmarc + # - marcmintel +device: 192.168.1.206:33055 +app-id: com.instagram.android +feed: 5-8 +explore: 3-5 +reels: 3-5 +stories: 3-5 +allow-untested-ig-version: true +debug: true +shuffle-jobs: true +total-sessions: 999 +total-interactions-limit: 10000 +repeat: 5-8 +comment-percentage: 100 +dry-run-comments: true +interact-percentage: 100 +follow-percentage: 100 +follow-limit: 50 +likes-count: 2-3 +likes-percentage: 100 +stories-count: 2-3 +stories-percentage: 30 +carousel-count: 2-3 +carousel-percentage: 70 +repost-percentage: 5 + +# --- Projekt Singularity V8: Ultra-Smarte Config --- +ai-model: qwen3.5:latest # Dein bestes lokales Modell fÃŧr Kommentare & Vibe +ai-model-url: http://localhost:11434/api/generate + +ai-telepathic-model: google/gemini-3.1-flash-lite-preview # Der Navigations-Champion +ai-telepathic-url: https://openrouter.ai/api/v1/chat/completions + +ai-fallback-model: qwen3.5:latest # Kein "Halluzinations-Risiko" mehr im Fallback +ai-fallback-url: http://localhost:11434/api/generate + +ai-condenser-model: llama3.2:1b # Reicht fÃŧr reine Zusammenfassung (spart VRAM) +ai-condenser-url: http://localhost:11434/api/generate +# ------------------------------- + +ai-quality-filter: true +ai-learn-own-profile: true +ai-learn-comments: true +ai-learn-niche-posts: true +ai-learn-only: false +ai-vibe: "friendly, authentic, helpful" +ai-target-audience: "travel, landscape, nature, mountain, photography, adventure, wanderlust, explore" +ai-blacklist-topics: "onlyfans, nsfw, sale, discount, promo, 18+, giveaway" +smart-unfollow: true +total-comments-limit: 5000 +dry-run: false +speed-multiplier: 1.0 +watch-photo-time: 1-3 +watch-video-time: 3-8 +dont-type: false +skipped-posts-limit: 10 +account-switch-delay: 10-20 diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/anomalies/test_bot_flow_edge_cases.py b/tests/anomalies/test_bot_flow_edge_cases.py new file mode 100644 index 0000000..b676fa5 --- /dev/null +++ b/tests/anomalies/test_bot_flow_edge_cases.py @@ -0,0 +1,128 @@ +import pytest +from unittest.mock import patch, MagicMock + +import sys +# Force mock qdrant_client before importing any core modules that depend on it + +from GramAddict.core.bot_flow import _extract_post_content, _run_zero_latency_feed_loop + +class TestBotFlowEdgeCases: + + def test_extract_post_content_edge_cases(self): + # 1. Empty string / Invalid XML should not crash + res = _extract_post_content("") + assert res.get("username") == "" + assert res.get("description") == "" + + # 2. Extract when only username exists + xml = "" + res = _extract_post_content(xml) + assert res.get("username") == "just_user" + assert res.get("description") == "" + + # 3. Extract when emoji only in description + xml = "" + res = _extract_post_content(xml) + # However, bot_flow requires len(desc) > 10! + # So "đŸ”ĨđŸ”ĨđŸ”Ĩ" will NOT be extracted if it's too short. Let's provide a long text. + xml = "" + res = _extract_post_content(xml) + assert res.get("description") == "đŸ”ĨđŸ”ĨđŸ”ĨđŸ”ĨđŸ”ĨđŸ”ĨđŸ”ĨđŸ”ĨđŸ”ĨđŸ”ĨđŸ”Ĩ" + + # 4. Another valid description tag + xml = "" + res = _extract_post_content(xml) + assert res.get("description") == "some desc with more than 10 chars limits" + + @patch('GramAddict.core.bot_flow.sleep') + @patch('GramAddict.core.bot_flow._humanized_scroll') + @patch('GramAddict.core.bot_flow.dump_ui_state') + @patch('GramAddict.core.bot_flow._detect_ad_structural') + @patch('GramAddict.core.bot_flow._align_active_post') + @patch('GramAddict.core.telepathic_engine.TelepathicEngine.get_instance') + def test_zero_node_recovery(self, mock_get_telepathic, mock_align, mock_ad, mock_dump, mock_scroll, mock_sleep): + # Tests the explicit Zero-Node Recovery added previously + device = MagicMock() + zero_engine = MagicMock() + nav_graph = MagicMock() + configs = MagicMock() + session_state = MagicMock() + + mock_ad.return_value = False + mock_align.return_value = False + + cognitive_stack = { + "dopamine": MagicMock(), + "darwin": MagicMock(), + "resonance": MagicMock(), + "active_inference": MagicMock(), + "growth_brain": MagicMock(), + "swarm": MagicMock() + } + + # Dopamine breaks loop after 1st iteration + cognitive_stack["dopamine"].is_app_session_over.side_effect = [False, True] + cognitive_stack["dopamine"].wants_to_change_feed.return_value = False + cognitive_stack["dopamine"].wants_to_doomscroll.return_value = False + + # Fake extreme limits => doesn't break limits + session_state.check_limit.return_value = [False]*10 + + # Telepathic Engine returns ZERO nodes on extract + mock_engine = MagicMock() + mock_engine._extract_semantic_nodes.return_value = [] + mock_get_telepathic.return_value = mock_engine + + device.deviceV2.dump_hierarchy.return_value = "" + + # Execute the main loop + _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session_state, "HomeFeed", cognitive_stack) + + # It should trigger device.press("back") and then _humanized_scroll + device.deviceV2.press.assert_called_with("back") + assert mock_scroll.call_count >= 1 + + @patch('GramAddict.core.bot_flow.sleep') + @patch('GramAddict.core.bot_flow._humanized_scroll') + @patch('GramAddict.core.bot_flow.dump_ui_state') + @patch('GramAddict.core.bot_flow._extract_post_content') + @patch('GramAddict.core.bot_flow._detect_ad_structural') + @patch('GramAddict.core.bot_flow._align_active_post') + @patch('GramAddict.core.telepathic_engine.TelepathicEngine.get_instance') + def test_content_extraction_failed_recovery(self, mock_get_telepathic, mock_align, mock_ad, mock_extract, mock_dump, mock_scroll, mock_sleep): + device = MagicMock() + zero_engine = MagicMock() + nav_graph = MagicMock() + configs = MagicMock() + session_state = MagicMock() + + mock_ad.return_value = False + mock_align.return_value = False + + cognitive_stack = { + "dopamine": MagicMock(), + "darwin": MagicMock() + } + # break after 1 loop + cognitive_stack["dopamine"].is_app_session_over.side_effect = [False, True] + cognitive_stack["dopamine"].wants_to_change_feed.return_value = False + cognitive_stack["dopamine"].wants_to_doomscroll.return_value = False + session_state.check_limit.return_value = [False]*10 + + # Ensure it HAS feed markers + device.deviceV2.dump_hierarchy.return_value = "row_feed_photo_profile_name" + + # Ensure interactive_nodes is NOT zero + mock_engine = MagicMock() + mock_engine._extract_semantic_nodes.return_value = [{"x": 10}] + mock_get_telepathic.return_value = mock_engine + + # Make the extraction fail + mock_extract.return_value = {"username": "", "description": ""} + + _run_zero_latency_feed_loop(device, zero_engine, nav_graph, configs, session_state, "HomeFeed", cognitive_stack) + + # Should call mock_scroll (Graceful degradation) + mock_scroll.assert_called_once() + mock_dump.assert_called_with(device, "content_extraction_failed", {"feed": "HomeFeed"}) + diff --git a/tests/anomalies/test_cognitive_edge_cases.py b/tests/anomalies/test_cognitive_edge_cases.py new file mode 100644 index 0000000..887e94a --- /dev/null +++ b/tests/anomalies/test_cognitive_edge_cases.py @@ -0,0 +1,57 @@ +import pytest + +from GramAddict.core.resonance_engine import ResonanceEngine +from GramAddict.core.darwin_engine import DarwinEngine +from GramAddict.core.growth_brain import GrowthBrain + +class TestCognitiveEdgeCases: + + # Resonance Engine + def test_resonance_edge_cases(self): + engine = ResonanceEngine(my_username="test_user") + + # 1. Empty strings shouldn't crash + assert engine.calculate_resonance({"description": "", "username": ""}) == 0.5 + + # 2. Very long descriptions + long_str = "word " * 10000 + res = engine.calculate_resonance({"description": long_str}) + assert isinstance(res, float) + + # 3. None values + score = engine.calculate_resonance({"description": None}) + assert score == 0.5 + + # Darwin Engine + def test_darwin_edge_cases(self): + engine = DarwinEngine("test_user") + + # 1. synthesize interaction with 0.0 + prof = engine.synthesize_interaction_profile(0.0) + assert prof["initial_dwell_sec"] > 0 + + # 2. Negative resonance (should default upwards or bound) + prof_neg = engine.synthesize_interaction_profile(-10.0) + assert prof_neg["initial_dwell_sec"] > 0 + + # 3. Extreme resonance + prof_max = engine.synthesize_interaction_profile(10.0) # > 1.0 + assert prof_max["initial_dwell_sec"] > 0 + + def test_growth_brain_edge_cases(self): + engine = GrowthBrain(username="test") + + # 1. Call circadian without history + engine.session_history = [] + pacing = engine.get_circadian_pacing() + assert 0.4 <= pacing <= 1.2 + + # 2. Call with extreme limits + engine.session_history = [{"boredom_peak": 100.0, "time": "unknown"}] * 100 + pacing2 = engine.get_circadian_pacing() + assert pacing2 > 0.0 + + # 3. Evaluate persona drift with empty outcomes + engine.refine_persona([]) + # Shouldn't crash + diff --git a/tests/anomalies/test_fsd_recovery.py b/tests/anomalies/test_fsd_recovery.py new file mode 100644 index 0000000..7ad3870 --- /dev/null +++ b/tests/anomalies/test_fsd_recovery.py @@ -0,0 +1,60 @@ +import os +import hashlib +from unittest.mock import MagicMock, patch +import pytest + +# Mock directory setup +ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +FIXTURE_DIR = os.path.join(ROOT_DIR, "fixtures") + +class ConfigMock: + def __init__(self): + self.args = MagicMock() + self.args.app_id = "com.instagram.android" + +def test_fsd_handles_persistent_survey_modal(): + """ + Simulates a case where the bot gets stuck on a survey modal. + The FSD (Full Self Driving) anomaly handler should trigger, + detect that 'Back' didn't work, and engage TelepathicEngine + to find and tap the 'Not Now' or 'Dismiss' button. + """ + from GramAddict.core.bot_flow import _run_zero_latency_feed_loop + from GramAddict.core.telepathic_engine import TelepathicEngine + + device = MagicMock() + device.app_id = "com.instagram.android" + device._get_current_app.return_value = "com.instagram.android" + configs = ConfigMock() + + # Mock the TelepathicEngine singleton behavior entirely + mock_telepathic = MagicMock() + mock_telepathic.find_best_node.return_value = {"x": 500, "y": 1400, "semantic": "Not Now"} + mock_telepathic._extract_semantic_nodes.return_value = [{"x": 10}] + + dopamine = MagicMock() + dopamine.is_app_session_over.side_effect = [False, False, True] # Run twice, then exit + dopamine.wants_to_change_feed.return_value = False + dopamine.wants_to_doomscroll.return_value = False + + ai = MagicMock() + ai.get_sleep_modifier.return_value = 1.0 + cognitive_stack = {"dopamine": dopamine, "growth_brain": None, "active_inference": ai, "telepathic": mock_telepathic} + + # Load the mock survey modal UI + xml_path = os.path.join(FIXTURE_DIR, "survey_modal.xml") + with open(xml_path, "r") as f: + alien_xml = f.read() + device.deviceV2.dump_hierarchy.return_value = alien_xml + + with patch('GramAddict.core.bot_flow.sleep'), \ + patch('GramAddict.core.bot_flow._humanized_scroll'), \ + patch('GramAddict.core.telepathic_engine.TelepathicEngine.get_instance', return_value=mock_telepathic): + + result = _run_zero_latency_feed_loop(device, None, MagicMock(), configs, MagicMock(), "HomeFeed", cognitive_stack) + + # VERIFICATION: + # Handler should have called Telepathic after 2 misses + assert mock_telepathic.find_best_node.called + assert device.deviceV2.click.called + assert result != "CONTEXT_LOST" diff --git a/tests/anomalies/test_hardware_anomalies.py b/tests/anomalies/test_hardware_anomalies.py new file mode 100644 index 0000000..dc371dd --- /dev/null +++ b/tests/anomalies/test_hardware_anomalies.py @@ -0,0 +1,166 @@ +import pytest +import os +import time +from unittest.mock import MagicMock, patch +from GramAddict.core.bot_flow import _wait_for_post_loaded, _run_zero_latency_feed_loop, FEED_MARKERS +from GramAddict.core.device_facade import DeviceFacade + +ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +DUMPS = { + "organic": os.path.join(ROOT_DIR, "fixtures", "organic_post.xml"), + "explore": os.path.join(ROOT_DIR, "fixtures", "explore_feed_dump.xml"), +} +FIXTURE_DIR = os.path.join(ROOT_DIR, "fixtures") + +def mutate_xml_to_foreign(xml_content: str) -> str: + """Removes meaningful text content to simulate a language failure or empty state.""" + import re + # Strip text and content-desc + xml = re.sub(r'text="[^"]*"', 'text=""', xml_content) + xml = re.sub(r'content-desc="[^"]*"', 'content-desc=""', xml) + return xml + +def mutate_xml_remove_feed_markers(xml_content: str) -> str: + """Removes all feed markers to simulate a grid view or random popup.""" + xml = xml_content + for marker in FEED_MARKERS: + xml = xml.replace(marker, "some_random_id") + return xml + +class ConfigMock: + def __init__(self): + self.args = MagicMock() + self.args.interact_percentage = 0 + self.args.comment_percentage = 0 + +@pytest.fixture +def test_dumps(): + dumps = {} + with open(DUMPS["organic"], "r") as f: + dumps["post"] = f.read() + # Fake explore grid that lacks ALL feed markers + dumps["grid"] = '' + return dumps + +def test_slow_loading_post_recovery(test_dumps): + """ + Test that _wait_for_post_loaded correctly handles a delay where the + first few dumps are grids, and only later it becomes a post. + """ + device = MagicMock() + # Simulate: Grid -> Grid -> Error -> Post + device.deviceV2.dump_hierarchy.side_effect = [ + test_dumps["grid"], + test_dumps["grid"], + Exception("uiautomator2 temp failure"), + test_dumps["post"] + ] + + # We patch sleep to make the test super fast + with patch('GramAddict.core.bot_flow.sleep', return_value=None): + start = time.time() + success = _wait_for_post_loaded(device, timeout=5) + # Should return true when it hits the 4th element + assert success is True + assert device.deviceV2.dump_hierarchy.call_count == 4 + +def test_wait_timeout_aborts_gracefully(test_dumps): + """Test what happens if the network is so slow it times out entirely.""" + device = MagicMock() + # Always return grid + device.deviceV2.dump_hierarchy.return_value = test_dumps["grid"] + + # Patch time.time to simulate 6 seconds passing immediately + # We add sequence padding because python's logger internally uses time.time() + with patch('GramAddict.core.bot_flow.time.time', side_effect=[0, 1, 6, 6, 6, 6, 6, 6, 6, 6]): + with patch('GramAddict.core.bot_flow.sleep', return_value=None): + success = _wait_for_post_loaded(device, timeout=5) + assert success is False + +def test_empty_content_extraction_guard(test_dumps): + """ + Test that if a post is loaded, but it has strange empty text (foreign language or bug), + the bot aborts interaction and scrolls instead of judging empty content. + """ + device = MagicMock() + nav_graph = MagicMock() + configs = ConfigMock() + + # We create a fake active inference engine to just break the loop after 1 iteration + ai = MagicMock() + # Dopamine engine controls loop exit + dopamine = MagicMock() + dopamine.is_app_session_over.side_effect = [False, True] # Run once, then exit + dopamine.wants_to_change_feed.return_value = False + dopamine.wants_to_doomscroll.return_value = False + + cognitive_stack = { + "dopamine": dopamine, + "active_inference": ai, + "resonance": None, "growth_brain": None, "swarm": None, "darwin": None + } + + # Mutate the post so it has NO text or description + broken_xml = mutate_xml_to_foreign(test_dumps["post"]) + device.deviceV2.dump_hierarchy.return_value = broken_xml + + with patch('GramAddict.core.bot_flow._humanized_scroll') as mock_scroll, \ + patch('GramAddict.core.bot_flow.sleep'): + + result = _run_zero_latency_feed_loop(device, None, nav_graph, configs, MagicMock(), "HomeFeed", cognitive_stack) + + # Ensure scroll was called (the recovery mechanism) + assert mock_scroll.called + # Check that we never called resonance evaluation because we broke early + assert not ai.predict_state.called + assert result == "SESSION_OVER" + +def test_missing_feed_markers_guard(test_dumps): + """ + Test that if the UI is completely foreign (e.g., a system popup), + the bot detects missing feed markers and scrolls to recover. + """ + device = MagicMock() + configs = ConfigMock() + + dopamine = MagicMock() + dopamine.is_app_session_over.side_effect = [False, True] + dopamine.wants_to_change_feed.return_value = False + dopamine.wants_to_doomscroll.return_value = False + + cognitive_stack = {"dopamine": dopamine, "growth_brain": None, "active_inference": None} + + # Mutate XML to remove all FEED MARKERS + alien_xml = mutate_xml_remove_feed_markers(test_dumps["post"]) + device.deviceV2.dump_hierarchy.return_value = alien_xml + + with patch('GramAddict.core.bot_flow._humanized_scroll') as mock_scroll, \ + patch('GramAddict.core.bot_flow.sleep'): + _run_zero_latency_feed_loop(device, None, MagicMock(), configs, MagicMock(), "HomeFeed", cognitive_stack) + +@patch('GramAddict.core.device_facade.u2') +def test_xpath_watcher_initialization(mock_u2): + """ + Test fixing the critical watcher API bug. + Ensures that device facade uses .watcher("name").when(xpath=...) + """ + mock_d = MagicMock() + mock_u2.connect.return_value = mock_d + + # Setup mock chain: deviceV2.watcher("crash_dialog").when(...) + mock_watcher = MagicMock() + mock_d.watcher.return_value = mock_watcher + mock_when = MagicMock() + mock_watcher.when.return_value = mock_when + + # Just init the facade + from GramAddict.core.device_facade import create_device + device = create_device("fake_serial", "com.fake.app", MagicMock()) + + # Verify exact API call structure for XPath + mock_d.watcher.assert_any_call("crash_dialog") + mock_d.watcher.assert_any_call("system_dialog") + + # We can't perfectly assert the chained arguments natively without a bit of inspection, + # but we can verify it didn't crash and called start + assert mock_d.watcher.start.called diff --git a/tests/anomalies/test_hardware_edge_cases.py b/tests/anomalies/test_hardware_edge_cases.py new file mode 100644 index 0000000..10d1313 --- /dev/null +++ b/tests/anomalies/test_hardware_edge_cases.py @@ -0,0 +1,47 @@ +import pytest +import os +from unittest.mock import MagicMock, patch +from GramAddict.core.device_facade import DeviceFacade + +def test_adb_retry_recovers_from_transient_error(): + # Attempt simulated disconnect on dump_hierarchy + device_id = "test" + app_id = "test" + + with patch('uiautomator2.connect') as mock_connect: + mock_device = MagicMock() + mock_connect.return_value = mock_device + + facade = DeviceFacade(device_id, app_id, None) + + # Make the first 2 calls fail, the 3rd one pass + mock_device.dump_hierarchy.side_effect = [ + Exception("ConnectError uiautomator2"), + Exception("RPC Error"), + "" + ] + + # Patch sleep to speed up test + with patch('GramAddict.core.device_facade.sleep'): + res = facade.dump_hierarchy() + assert res == "" + assert mock_device.dump_hierarchy.call_count == 3 + +def test_adb_retry_crashes_gracefully_after_all_retries(): + # Attempt simulated disconnect on dump_hierarchy + device_id = "test" + app_id = "test" + + with patch('uiautomator2.connect') as mock_connect: + mock_device = MagicMock() + mock_connect.return_value = mock_device + + facade = DeviceFacade(device_id, app_id, None) + + # Always fail + mock_device.dump_hierarchy.side_effect = Exception("Permanent ConnectError") + + with patch('GramAddict.core.device_facade.sleep'): + with pytest.raises(Exception, match="Permanent ConnectError"): + facade.dump_hierarchy() + assert mock_device.dump_hierarchy.call_count == 3 diff --git a/tests/anomalies/test_human_hesitation.py b/tests/anomalies/test_human_hesitation.py new file mode 100644 index 0000000..eee5558 --- /dev/null +++ b/tests/anomalies/test_human_hesitation.py @@ -0,0 +1,81 @@ +import unittest +import sys +import os + +# Add parent dir to path +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from GramAddict.core.telepathic_engine import TelepathicEngine + +class DummyDevice: + class DeviceV2: + def __init__(self): + self.last_click = None + + def click(self, x, y): + self.last_click = (x, y) + + def screenshot(self, path=None): + return "fake_screenshot" + + def __init__(self): + self.deviceV2 = self.DeviceV2() + self.app_id = "com.instagram.android" + + def _get_current_app(self): + return "com.instagram.android" + +class TestHumanHesitation(unittest.TestCase): + def setUp(self): + self.telepathic = TelepathicEngine() + self.device = DummyDevice() + + def test_discard_dialog_extraction(self): + """ + Prove that the Telepathic Engine can correctly identify the 'Discard' + button inside a synthetic XML dump, ensuring the 'Umentscheidung' + abort logic works in the wild. + """ + # Synthetic Discard Dialog XML + synthetic_dump = ''' + + + + + + + + ''' + + # Act + result = self.telepathic.find_best_node( + synthetic_dump, + "Discard or Verwerfen popup button to cancel comment", + device=self.device + ) + + # Assert (Should hit the [600,1200][800,1300] box, which centers to (700, 1250)) + self.assertIsNotNone(result, "Telepathic engine failed to find 'Verwerfen'.") + self.assertEqual(result["x"], 700) + self.assertEqual(result["y"], 1250) + + def test_dm_inbox_tab_resolution(self): + """ + Verify that teleporting specifically to the Inbox tab (DM button) + succeeds if 'Message' describes it. + """ + synthetic_dump = ''' + + + + + ''' + + # If ID didn't match perfectly, we fall back to description as programmed. + # Direct simulation of UI Automator check isn't in scope for this telepathic test, + # but we can ensure Telepathic Engine CAN find it if we rely on it. + result = self.telepathic.find_best_node(synthetic_dump, "Direct messages tab button", device=self.device) + self.assertIsNotNone(result, "Should find the Message tab") + +if __name__ == '__main__': + unittest.main() diff --git a/tests/anomalies/test_llm_hallucination_recovery.py b/tests/anomalies/test_llm_hallucination_recovery.py new file mode 100644 index 0000000..93b400d --- /dev/null +++ b/tests/anomalies/test_llm_hallucination_recovery.py @@ -0,0 +1,56 @@ +import pytest +from unittest.mock import patch, MagicMock +from GramAddict.core.llm_provider import query_llm +from GramAddict.core.resonance_engine import ResonanceEngine + +def test_query_llm_hallucination_recovery(): + # Test that when the primary model hallucinates non-JSON, it triggers fallback + with patch('requests.post') as mock_post: + # 1st call: Primary fails entirely (e.g., Timeout or strange error) + mock_response_1 = MagicMock() + mock_response_1.status_code = 500 + mock_response_1.raise_for_status.side_effect = Exception("500 Server Error") + + # 2nd call: Fallback works and returns valid JSON + mock_response_2 = MagicMock() + mock_response_2.status_code = 200 + mock_response_2.raise_for_status.return_value = None + mock_response_2.json.return_value = { + "choices": [{"message": {"content": '{"test": "success"}'}}] + } + + mock_post.side_effect = [mock_response_1, mock_response_2] + + # Attempt a query with a primary model + res = query_llm( + url="http://fake.api/v1/chat/completions", + model="primary-model", + prompt="Hello", + format_json=True, + fallback_model="fallback-model", + fallback_url="http://fake.api/v1/chat/completions" + ) + + assert res is not None + assert "response" in res + assert res["response"] == '{"test": "success"}' + assert mock_post.call_count == 2 + +def test_query_llm_double_hallucination_safe_return(): + # Test that when both models hallucinate, we return None gracefully + with patch('requests.post') as mock_post: + # Both models fail + mock_response = MagicMock() + mock_response.status_code = 500 + mock_response.raise_for_status.side_effect = Exception("500 Server Error") + + mock_post.side_effect = [mock_response, mock_response] + + res = query_llm( + url="http://fake.api/v1/chat/completions", + model="primary-model", + prompt="Hello", + format_json=True + ) + + assert res is None diff --git a/tests/anomalies/test_nav_failure_tdd.py b/tests/anomalies/test_nav_failure_tdd.py new file mode 100644 index 0000000..ead2359 --- /dev/null +++ b/tests/anomalies/test_nav_failure_tdd.py @@ -0,0 +1,41 @@ +import pytest +import os +from unittest.mock import MagicMock, patch +from GramAddict.core.q_nav_graph import QNavGraph + +def test_tap_home_tab_recovery_from_homescreen(): + """ + TDD: Reproduce the failure where tap_home_tab fails because the bot is on + the Android Homescreen (app.lawnchair), and verify that it recovers + via app_start instead of enterring an auto-repair loop. + """ + # 1. Setup Mock Device + mock_device = MagicMock() + mock_device.app_id = "com.instagram.android" + # Return homescreen package to simulate context loss + mock_device._get_current_app.return_value = "app.lawnchair" + + # 2. Mock DeviceV2 responses + mock_device.deviceV2.dump_hierarchy.return_value = "" + mock_device.deviceV2.app_start.return_value = True + + # 3. Initialize NavGraph + graph = QNavGraph(mock_device) + graph.current_state = "ProfileFeed" # Assume stale state + + # 4. Patch TelepathicEngine.get_instance to return a mock engine + with patch("GramAddict.core.telepathic_engine.TelepathicEngine.get_instance") as mock_get_instance, \ + patch("GramAddict.core.q_nav_graph.time.sleep"): + mock_engine = MagicMock() + mock_get_instance.return_value = mock_engine + + # Simulate Context Guard hitting: return None forever + mock_engine.find_best_node.return_value = None + + # 5. Execute + # We expect this to return False gracefully after 3 attempts, without infinitely looping + success = graph.navigate_to("ExploreFeed", zero_engine=None) + + # 6. Assertion + assert not success, "Navigation should fail gracefully when context cannot be recovered" + assert mock_device.deviceV2.app_start.called, "Should have force-started the app when context was lost" diff --git a/tests/anomalies/test_nav_graph_edge_cases.py b/tests/anomalies/test_nav_graph_edge_cases.py new file mode 100644 index 0000000..dc4cc59 --- /dev/null +++ b/tests/anomalies/test_nav_graph_edge_cases.py @@ -0,0 +1,106 @@ +import pytest +from unittest.mock import patch, MagicMock + +import sys +# Force mock qdrant_client before importing any core modules that depend on it + +from GramAddict.core.q_nav_graph import QNavGraph + +class TestQNavGraphEdgeCases: + + @pytest.fixture(autouse=True) + def setup_graph(self): + self.device = MagicMock() + self.device.app_id = "com.instagram.android" + self.device._get_current_app = MagicMock(return_value="com.instagram.android") + + # Prevent Dojo engine instantiation during tests + with patch('GramAddict.core.compiler_engine.VLMCompilerEngine'): + self.graph = QNavGraph(self.device) + + def test_find_path_edge_cases(self): + # 1. Start == End + assert self.graph._find_path("HomeFeed", "HomeFeed") == [] + + # 2. Start not in nodes + assert self.graph._find_path("UnknownState", "HomeFeed") == None + + # 3. Unreachable states + self.graph.nodes = { + "HomeFeed": {"transitions": {"tap_explore": "ExploreFeed"}}, + "IsolatedFeed": {"transitions": {}} + } + assert self.graph._find_path("HomeFeed", "IsolatedFeed") == None + + # 4. Infinite loop protection (A -> B -> A) + self.graph.nodes = { + "A": {"transitions": {"to_b": "B"}}, + "B": {"transitions": {"to_a": "A"}} + } + assert self.graph._find_path("A", "C") == None # Should safely return None without exceeding recursion/loop depth + + # 5. Longest path possible before unreachability is confirmed + assert self.graph._find_path("B", "D") == None + + # 6. Diamond shape path + self.graph.nodes = { + "Start": {"transitions": {"top": "Top", "bottom": "Bottom"}}, + "Top": {"transitions": {"top_to_end": "End"}}, + "Bottom": {"transitions": {"bottom_to_end": "End"}}, + "End": {} + } + # BFS should find shortest path (len 2) + assert len(self.graph._find_path("Start", "End")) == 2 + + @patch('GramAddict.core.telepathic_engine.TelepathicEngine.get_instance') + def test_execute_transition_edge_cases(self, mock_get_telepathic): + from GramAddict.core.telepathic_engine import TelepathicEngine + mock_engine = MagicMock(spec=TelepathicEngine) + mock_get_telepathic.return_value = mock_engine + + zero_engine = MagicMock() + + # Case 1: Telepathic engine finds nothing + mock_engine.find_best_node.return_value = None + + # If still in Instagram, it returns False + self.device._get_current_app.return_value = "com.instagram.android" + assert self.graph._execute_transition("unknown_action", zero_engine) == False + + # If app is different, it returns "CONTEXT_LOST" + self.device._get_current_app.return_value = "com.android.launcher3" + assert self.graph._execute_transition("unknown_action", zero_engine) == "CONTEXT_LOST" + + # Case 2: Best node has skip flag + mock_engine.find_best_node.return_value = {"skip": True} + assert self.graph._execute_transition("already_done_action", zero_engine) == True + + # Case 3: Proper interaction, but XML doesn't change (verification fail) + mock_engine.find_best_node.return_value = {"x": 10, "y": 10, "score": 0.9} + self.device.deviceV2.dump_hierarchy.side_effect = ["same", "same"] + assert self.graph._execute_transition("click_action", zero_engine) == False + mock_engine.reject_click.assert_called_once() + + # Case 4: Proper interaction, XML changes (verification pass) + mock_engine.reset_mock() + mock_engine.find_best_node.return_value = {"x": 10, "y": 10, "score": 0.9} + self.device.deviceV2.dump_hierarchy.side_effect = ["before", "after"] + assert self.graph._execute_transition("click_action", zero_engine) == True + mock_engine.confirm_click.assert_called_once() + + @patch('GramAddict.core.dojo_engine.DojoEngine.get_instance') + def test_navigate_to_recovery_edge_cases(self, mock_dojo): + # We test the deepest recovery logic: when everything fails + + zero_engine = MagicMock() + + # Mock transitions completely failing + with patch.object(self.graph, '_execute_transition', return_value=False): + # Recovery attempts maxed out + assert self.graph.navigate_to("ExploreFeed", zero_engine, recovery_attempts=3) == False + + # Start logic where path is None and direct fallback also fails + self.graph.current_state = "IsolatedNode" + # It should trigger fallback and then return False because `_execute_transition` always returns False + assert self.graph.navigate_to("ExploreFeed", zero_engine, recovery_attempts=0) == False + diff --git a/tests/anomalies/test_xml_dumps_fuzz.py b/tests/anomalies/test_xml_dumps_fuzz.py new file mode 100644 index 0000000..e50510e --- /dev/null +++ b/tests/anomalies/test_xml_dumps_fuzz.py @@ -0,0 +1,64 @@ +import os +import glob +import pytest +from unittest.mock import patch, MagicMock + +# Removed sys.modules poison that mock qdrant_client globally + +from GramAddict.core.telepathic_engine import TelepathicEngine + +# Path to real xml dumps +DUMPS_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "debug", "xml_dumps") + +# Gather all XML files +xml_files = glob.glob(os.path.join(DUMPS_DIR, "*.xml")) + +if not xml_files: + print(f"WARNING: No xml dumps found in {DUMPS_DIR}. Fuzzer cannot run.") + xml_files = ["dummy_path_to_prevent_pytest_crash"] + +@pytest.fixture(autouse=True) +def mock_ai_services(): + """Ensure that the fuzzer never makes real LLM API or Qdrant DB calls.""" + with patch('GramAddict.core.qdrant_memory.QdrantClient'), \ + patch('GramAddict.core.qdrant_memory.QdrantBase._get_embedding', return_value=[0.0]*1536), \ + patch('GramAddict.core.telepathic_engine.query_telepathic_llm', return_value='{"index": 0, "reason": "Fuzz Mock"}'): + yield + +@pytest.mark.parametrize("xml_path", xml_files, ids=lambda x: os.path.basename(x)) +def test_xml_parser_does_not_crash(xml_path): + """ + Reads an arbitrary XML dump from the physical device during crash events + and guarantees that the core TelepathicEngine parser handles it gracefully. + """ + if xml_path == "dummy_path_to_prevent_pytest_crash": + pytest.skip("No XML dumps found. Skipping fuzzer.") + if not os.path.exists(xml_path): + pytest.skip(f"XML dump missing: {xml_path}") + + with open(xml_path, "r", encoding="utf-8") as f: + xml_content = f.read() + + engine = TelepathicEngine() + + try: + # Phase 1: Pure parsing stability + nodes = engine._extract_semantic_nodes(xml_content) + + # Verify node structure if nodes exist + for n in nodes: + assert "raw_bounds" in n, f"Extracted node is missing raw_bounds. Content: {n}" + assert "semantic_string" in n, f"Extracted node missing semantic_string. Content: {n}" + + if len(nodes) == 0: + print(f"WARN: {os.path.basename(xml_path)} parsed perfectly, but yielded ZERO readable nodes.") + + # Phase 2: Query resolution stability (Keyword + Vector + VLM Fallbacks) + device_mock = MagicMock() + # Find completely arbitrary intent, just to trigger full resolution path + best_node = engine.find_best_node(xml_content, "dismiss this modal immediately or try clicking like", device=device_mock) + + # It's totally fine if `best_node` is None (e.g. 0 nodes). We just verify NO Crash. + + except Exception as e: + pytest.fail(f"Fuzz test crashed on {os.path.basename(xml_path)} with error: {str(e)}") diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..f272612 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,105 @@ +import pytest +import logging +from unittest.mock import MagicMock +MagicMock.app_id = "com.instagram.android" +MagicMock._get_current_app = MagicMock(return_value="com.instagram.android") + +class MockArgs: + def __init__(self, **kwargs): + for k, v in kwargs.items(): + setattr(self, k, v) + +class MockConfigs: + def __init__(self, args): + self.args = args + +class MockDeviceV2: + def __init__(self): + self.clicks = [] + self.shells = [] + self.double_clicks = [] + self.presses = [] + self.xml_dump = "" + + def click(self, x, y): + self.clicks.append((x, y)) + + def shell(self, cmd): + self.shells.append(cmd) + + def double_click(self, x, y, duration=0): + self.double_clicks.append((x, y)) + + def press(self, key): + self.presses.append(key) + + def dump_hierarchy(self): + return self.xml_dump + + +class MockDevice: + def __init__(self): + self.deviceV2 = MockDeviceV2() + + def get_info(self): + return {"displayWidth": 1080, "displayHeight": 2400} + + def cm_to_pixels(self, cm): + return cm * 10 + +class MockTelepathicEngine: + def find_best_node(self, xml, intent_description, device=None, **kwargs): + description = intent_description.lower() + if "story ring" in description: + return {"x": 100, "y": 100, "description": "Story Ring", "score": 1.0} + if "follow" in description or "folgen" in description: + return {"x": 200, "y": 200, "text": "Follow", "description": "Follow Button", "score": 1.0} + if "first image" in description or "profile grid" in description: + return {"x": 300, "y": 300, "description": "Grid Image", "score": 1.0} + return None + + def _extract_semantic_nodes(self, xml): + return [{"x": 10, "y": 10}] + + def confirm_click(self, *args, **kwargs): + pass + + def reject_click(self, *args, **kwargs): + pass + + @classmethod + def get_instance(cls): + return cls() + +@pytest.fixture +def mock_logger(): + return logging.getLogger("test") + +@pytest.fixture +def device(): + return MockDevice() + +@pytest.fixture(autouse=True) +def telepathic_mock(monkeypatch): + import GramAddict.core.telepathic_engine + engine = MockTelepathicEngine() + monkeypatch.setattr(GramAddict.core.telepathic_engine.TelepathicEngine, "get_instance", lambda: engine) + return engine + +@pytest.fixture +def mock_cognitive_stack(): + stack = { + "dopamine": MagicMock(), + "darwin": MagicMock(), + "resonance": MagicMock(), + "active_inference": MagicMock(), + "growth_brain": MagicMock(), + "swarm": MagicMock(), + "radome": MagicMock(), + "nav_graph": MagicMock(), + "zero_engine": MagicMock(), + "crm": MagicMock(), + "telepathic": MockTelepathicEngine() + } + stack["radome"].sanitize_xml.side_effect = lambda x: x + return stack diff --git a/tests/e2e/__init__.py b/tests/e2e/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/e2e/conftest.py b/tests/e2e/conftest.py new file mode 100644 index 0000000..e031393 --- /dev/null +++ b/tests/e2e/conftest.py @@ -0,0 +1,126 @@ +import sys +import os +import pytest +import time +from unittest.mock import MagicMock +from GramAddict.core import utils + +# Force Qdrant mocking globally across ALL E2E tests so we never +# block on connection refused trying to hit localhost:6344 +mock_qdrant = MagicMock() + +# Setup correct return types for dimension check warnings in qdrant_memory +mock_collection = MagicMock() +mock_collection.config.params.vectors.size = 768 +mock_qdrant.get_collection.return_value = mock_collection + +sys.modules["qdrant_client"].QdrantClient = MagicMock(return_value=mock_qdrant) + +@pytest.fixture +def e2e_device_dump_injector(): + """ + Provides a factory to mock device.deviceV2.dump_hierarchy using real XML files. + Will gracefully fail with a comprehensive assertion if the file is missing + (per 'ECHTE DUMPS fehlen' reporting requirement). + """ + def _inject_dump(device_mock, xml_filename): + fix_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "fixtures") + xml_path = os.path.join(fix_dir, xml_filename) + + if not os.path.exists(xml_path): + pytest.fail(f"MISSING REAL DUMP: required XML fixture '{xml_filename}' for full E2E workflow testing could not be found at {xml_path}. FAKE_NOTHING policy implies dropping this test execution until it is captured.", pytrace=False) + + with open(xml_path, "r") as f: + real_xml = f.read() + + device_mock.deviceV2.dump_hierarchy.return_value = real_xml + return real_xml + + return _inject_dump + +@pytest.fixture +def dynamic_e2e_dump_injector(monkeypatch): + """ + State-Machine Injector: Replaces dump_hierarchy dynamically when transitions occur. + Validates that the Telepathic Engine's pathfinding truly worked. + """ + def _inject(device_mock, state_map, initial_xml): + fix_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "fixtures") + + def load_xml(filename): + path = os.path.join(fix_dir, filename) + if not os.path.exists(path): + pytest.fail(f"MISSING REAL DUMP: {filename} not found.") + with open(path, "r") as f: + return f.read() + + device_mock.deviceV2.dump_hierarchy.return_value = load_xml(initial_xml) + + from GramAddict.core.q_nav_graph import QNavGraph + original_execute = QNavGraph._execute_transition + + def _mock_execute_transition(nav_self, action, zero_engine): + if action == 'tap_post_username': + return True + + # Evaluate using the real internal LLM/Keyword logic against the current mock XML! + success = original_execute(nav_self, action, zero_engine) + if success is True and action in state_map: + # The node was clicked successfully! Swap the XML to the target state. + device_mock.deviceV2.dump_hierarchy.return_value = load_xml(state_map[action]) + return success + + monkeypatch.setattr(QNavGraph, "_execute_transition", _mock_execute_transition) + + return _inject + +@pytest.fixture(autouse=True) +def mock_all_delays(monkeypatch): + """ + Strips out all humanized hardware delays specifically for the E2E test suite. + Ensures loops evaluate instantly using the injected dumps. + """ + monkeypatch.setattr(time, "sleep", lambda x: None) + monkeypatch.setattr(utils, "random_sleep", lambda *args, **kwargs: None) + monkeypatch.setattr(utils, "sleep", lambda x: None) + + # Standardize DarwinEngine across tests to prevent mockup math errors on session end + try: + from GramAddict.core.darwin_engine import DarwinEngine + monkeypatch.setattr(DarwinEngine, "evaluate_session_end", lambda *args, **kwargs: None) + except ImportError: + pass + +@pytest.fixture +def e2e_configs(): + import argparse + configs = MagicMock() + configs.args = argparse.Namespace( + username="testuser", + device="emulator-5554", + app_id="com.instagram.android", + debug=True, + feed=None, + carousel_percentage=0, + carousel_count="1", + explore=None, + reels=None, + stories=None, + interact_percentage=0, + likes_percentage=0, + follow_percentage=0, + comment_percentage=0, + working_hours=[0.0, 24.0], + time_delta_session=0, + speed_multiplier=1.0, + disable_filters=False, + interaction_users_amount="1", + scrape_profiles=False, + disable_ai_messaging=True, + total_unfollows_limit=0, + ai_telepathic_url="http://localhost", + ai_telepathic_model="llama3", + ai_condenser_url="http://localhost", + ai_condenser_model="llama3" + ) + return configs diff --git a/tests/e2e/test_e2e_carousel_sequence.py b/tests/e2e/test_e2e_carousel_sequence.py new file mode 100644 index 0000000..3fb455f --- /dev/null +++ b/tests/e2e/test_e2e_carousel_sequence.py @@ -0,0 +1,50 @@ +import pytest +from unittest.mock import MagicMock, patch +from GramAddict.core.bot_flow import start_bot + +@patch("GramAddict.core.bot_flow.open_instagram", return_value=True) +@patch("GramAddict.core.bot_flow.close_instagram") +@patch("GramAddict.core.bot_flow.sleep") +@patch("GramAddict.core.bot_flow.random_sleep") +@patch("GramAddict.core.bot_flow.create_device") +@patch("GramAddict.core.bot_flow.SessionState") +@patch("GramAddict.core.bot_flow.DopamineEngine") +@patch("GramAddict.core.bot_flow._humanized_horizontal_swipe") +def test_full_e2e_carousel_handling( + mock_swipe, mock_dopamine, mock_sess, mock_create_device, mock_rsleep, mock_sleep, mock_close, mock_open, dynamic_e2e_dump_injector, e2e_configs +): + """ + Tests that the core feed loop successfully identifies native Carousel identifiers + in the XML and initiates organic swiping inputs. + """ + device = MagicMock() + device.get_info.return_value = {"displayWidth": 1080, "displayHeight": 2400} + mock_create_device.return_value = device + + mock_d_inst = mock_dopamine.return_value + mock_d_inst.is_app_session_over.side_effect = [False, False, True] + mock_d_inst.wants_to_change_feed.return_value = False + mock_d_inst.wants_to_doomscroll.return_value = False + mock_d_inst.boredom = 0.0 + + mock_sess.inside_working_hours.side_effect = [(True, 0), Exception("Clean Exit for Carousel")] + + e2e_configs.args.feed = "1-2" + e2e_configs.args.carousel_percentage = 100 + e2e_configs.args.carousel_count = "3-3" + + # Load the captured UI dump containing native carousel_page_indicator + dynamic_e2e_dump_injector(device, {}, "carousel_post_dump.xml") + + try: + with patch("GramAddict.core.bot_flow.Config", return_value=e2e_configs): + with patch("GramAddict.core.bot_flow.QNavGraph.navigate_to", return_value=True): + with patch("secrets.choice", return_value="HomeFeed"): + with patch("random.random", return_value=0.0): + start_bot() + except Exception as e: + assert str(e) == "Clean Exit for Carousel" + + # Verify that the bot accurately parsed the JSON/XML, detected the Carousel, + # and initiated exactly 3 horizontal right-to-left swipes as requested by args. + assert mock_swipe.call_count == 3 diff --git a/tests/e2e/test_e2e_dm_sequence.py b/tests/e2e/test_e2e_dm_sequence.py new file mode 100644 index 0000000..610ba0a --- /dev/null +++ b/tests/e2e/test_e2e_dm_sequence.py @@ -0,0 +1,46 @@ +import pytest +from unittest.mock import MagicMock, patch +from GramAddict.core.bot_flow import start_bot + +@patch("GramAddict.core.bot_flow.open_instagram", return_value=True) +@patch("GramAddict.core.bot_flow.close_instagram") +@patch("GramAddict.core.bot_flow.sleep") +@patch("GramAddict.core.bot_flow.random_sleep") +@patch("GramAddict.core.bot_flow.create_device") +@patch("GramAddict.core.bot_flow.SessionState") +@patch("GramAddict.core.bot_flow.DopamineEngine") +def test_full_e2e_dm_sequence( + mock_dopamine, mock_sess, mock_create_device, mock_sleep, mock_close, mock_open, dynamic_e2e_dump_injector +): + device = MagicMock() + mock_create_device.return_value = device + mock_d_inst = mock_dopamine.return_value + mock_d_inst.is_app_session_over.side_effect = [False, True] + mock_d_inst.boredom = 0.0 + mock_sess.inside_working_hours.side_effect = [(True, 0), Exception("Clean Exit for DM")] + + class ConfigArgs: + username = "testuser" + device = "emulator-5554" + app_id = "com.instagram.android" + debug = True + disable_ai_messaging = False + feed = None + reels = None + explore = None + stories = None + total_unfollows_limit = 0 + + configs = MagicMock() + configs.args = ConfigArgs() + + dynamic_e2e_dump_injector(device, {'tap_message_icon': 'dm_inbox_dump.xml'}, "home_feed_with_ad.xml") + + # Let the core system hit its real execution loop with actual XMLs instead of circumventing it + try: + with patch("secrets.choice", return_value="MessageInbox"): + start_bot(configs=configs) + except Exception as e: + assert str(e) == "Clean Exit for DM" + + mock_open.assert_called() diff --git a/tests/e2e/test_e2e_dojo_integration.py b/tests/e2e/test_e2e_dojo_integration.py new file mode 100644 index 0000000..1c86650 --- /dev/null +++ b/tests/e2e/test_e2e_dojo_integration.py @@ -0,0 +1,44 @@ +import pytest +from unittest.mock import MagicMock, patch +from GramAddict.core.bot_flow import start_bot + +@patch("GramAddict.core.bot_flow.open_instagram", return_value=True) +@patch("GramAddict.core.bot_flow.close_instagram") +@patch("GramAddict.core.bot_flow.sleep") +@patch("GramAddict.core.bot_flow.random_sleep") +@patch("GramAddict.core.bot_flow.create_device") +@patch("GramAddict.core.bot_flow.SessionState") +@patch("GramAddict.core.bot_flow.DojoEngine") +def test_dojo_lifecycle_integration( + mock_dojo, mock_sess, mock_create_device, mock_rsleep, mock_sleep, mock_close, mock_open, dynamic_e2e_dump_injector +): + device = MagicMock() + mock_create_device.return_value = device + + mock_dojo_inst = mock_dojo.get_instance.return_value + mock_dojo_inst.is_running = True + + mock_sess.inside_working_hours.side_effect = [Exception("Lifecycle Exit")] + + class ConfigArgs: + username = "testuser" + device = "emulator-5554" + app_id = "com.instagram.android" + debug = True + feed = "1" + working_hours = "00:00-23:59" + time_delta_session = "0" + + configs = MagicMock() + configs.args = ConfigArgs() + + dynamic_e2e_dump_injector(device, {'tap_profile_tab': 'scraping_profile_dump.xml'}, "home_feed_with_ad.xml") + + try: + start_bot(configs=configs) + except Exception as e: + assert "Lifecycle Exit" in str(e) + + mock_dojo.get_instance.assert_called() + mock_dojo_inst.start.assert_called() + mock_dojo_inst.stop.assert_called() diff --git a/tests/e2e/test_e2e_explore_feed.py b/tests/e2e/test_e2e_explore_feed.py new file mode 100644 index 0000000..679743b --- /dev/null +++ b/tests/e2e/test_e2e_explore_feed.py @@ -0,0 +1,49 @@ +import pytest +from unittest.mock import MagicMock, patch +from GramAddict.core.bot_flow import start_bot + +@patch("GramAddict.core.bot_flow.open_instagram", return_value=True) +@patch("GramAddict.core.bot_flow.close_instagram") +@patch("GramAddict.core.bot_flow.sleep") +@patch("GramAddict.core.bot_flow.random_sleep") +@patch("GramAddict.core.bot_flow.create_device") +@patch("GramAddict.core.bot_flow.SessionState") +@patch("GramAddict.core.bot_flow.DopamineEngine") +def test_full_e2e_explore_feed_sequence( + mock_dopamine, mock_sess, mock_create_device, mock_sleep, mock_close, mock_open, dynamic_e2e_dump_injector +): + device = MagicMock() + mock_create_device.return_value = device + mock_d_inst = mock_dopamine.return_value + mock_d_inst.is_app_session_over.side_effect = [False, True] + mock_d_inst.boredom = 0.0 + mock_sess.inside_working_hours.side_effect = [(True, 0), Exception("Clean Exit for Explore")] + + class ConfigArgs: + username = "testuser" + device = "emulator-5554" + app_id = "com.instagram.android" + debug = True + explore = "5-8" + feed = None + reels = None + stories = None + interact_percentage = 0 + likes_percentage = 0 + follow_percentage = 0 + comment_percentage = 0 + + configs = MagicMock() + configs.args = ConfigArgs() + + # The actual dump we need for this workflow (available in fixtures/fixtures) + # The fixture will automatically hit pytest.fail if the dump vanishes. + dynamic_e2e_dump_injector(device, {'tap_explore_tab': 'explore_feed_dump.xml'}, "home_feed_with_ad.xml") + + try: + with patch("secrets.choice", return_value="ExploreFeed"): + start_bot(configs=configs) + except Exception as e: + assert str(e) == "Clean Exit for Explore" + + mock_open.assert_called() diff --git a/tests/e2e/test_e2e_home_feed.py b/tests/e2e/test_e2e_home_feed.py new file mode 100644 index 0000000..8b2b26f --- /dev/null +++ b/tests/e2e/test_e2e_home_feed.py @@ -0,0 +1,54 @@ +import pytest +from unittest.mock import MagicMock, patch +from GramAddict.core.bot_flow import start_bot + +@patch("GramAddict.core.bot_flow.open_instagram", return_value=True) +@patch("GramAddict.core.bot_flow.close_instagram") +@patch("GramAddict.core.bot_flow.sleep") +@patch("GramAddict.core.bot_flow.random_sleep") +@patch("GramAddict.core.bot_flow.create_device") +@patch("GramAddict.core.bot_flow.SessionState") +@patch("GramAddict.core.bot_flow.DopamineEngine") +def test_full_e2e_home_feed_sequence( + mock_dopamine, mock_sess, mock_create_device, mock_sleep, mock_close, mock_open, dynamic_e2e_dump_injector +): + """ + Test a full E2E sequence for Home Feed using actual real XML dumps. + """ + device = MagicMock() + mock_create_device.return_value = device + + # Setup mock dopamine & session + mock_d_inst = mock_dopamine.return_value + mock_d_inst.is_app_session_over.side_effect = [False, True] + mock_d_inst.boredom = 0.0 + + mock_sess.inside_working_hours.side_effect = [(True, 0), Exception("Clean Exit for Home")] + + class ConfigArgs: + username = "testuser" + device = "emulator-5554" + app_id = "com.instagram.android" + debug = True + feed = "5-8" + explore = None + reels = None + stories = None + interact_percentage = 0 + likes_percentage = 0 + follow_percentage = 0 + comment_percentage = 0 + + configs = MagicMock() + configs.args = ConfigArgs() + + dynamic_e2e_dump_injector(device, {}, "home_feed_with_ad.xml") + + try: + # We must also mock secrets.choice to ensure HomeFeed is picked + with patch("secrets.choice", return_value="HomeFeed"): + start_bot(configs=configs) + except Exception as e: + assert str(e) == "Clean Exit for Home" + + mock_open.assert_called() diff --git a/tests/e2e/test_e2e_reels_feed.py b/tests/e2e/test_e2e_reels_feed.py new file mode 100644 index 0000000..a803410 --- /dev/null +++ b/tests/e2e/test_e2e_reels_feed.py @@ -0,0 +1,47 @@ +import pytest +from unittest.mock import MagicMock, patch +from GramAddict.core.bot_flow import start_bot + +@patch("GramAddict.core.bot_flow.open_instagram", return_value=True) +@patch("GramAddict.core.bot_flow.close_instagram") +@patch("GramAddict.core.bot_flow.sleep") +@patch("GramAddict.core.bot_flow.random_sleep") +@patch("GramAddict.core.bot_flow.create_device") +@patch("GramAddict.core.bot_flow.SessionState") +@patch("GramAddict.core.bot_flow.DopamineEngine") +def test_full_e2e_reels_feed_sequence( + mock_dopamine, mock_sess, mock_create_device, mock_sleep, mock_close, mock_open, dynamic_e2e_dump_injector +): + device = MagicMock() + mock_create_device.return_value = device + mock_d_inst = mock_dopamine.return_value + mock_d_inst.is_app_session_over.side_effect = [False, True] + mock_d_inst.boredom = 0.0 + mock_sess.inside_working_hours.side_effect = [(True, 0), Exception("Clean Exit for Reels")] + + class ConfigArgs: + username = "testuser" + device = "emulator-5554" + app_id = "com.instagram.android" + debug = True + reels = "10" + feed = None + explore = None + stories = None + interact_percentage = 0 + likes_percentage = 0 + follow_percentage = 0 + comment_percentage = 0 + + configs = MagicMock() + configs.args = ConfigArgs() + + dynamic_e2e_dump_injector(device, {'tap_reels_tab': 'reels_feed_dump.xml'}, "home_feed_with_ad.xml") + + try: + with patch("secrets.choice", return_value="ReelsFeed"): + start_bot(configs=configs) + except Exception as e: + assert str(e) == "Clean Exit for Reels" + + mock_open.assert_called() diff --git a/tests/e2e/test_e2e_scraping_sequence.py b/tests/e2e/test_e2e_scraping_sequence.py new file mode 100644 index 0000000..5f87488 --- /dev/null +++ b/tests/e2e/test_e2e_scraping_sequence.py @@ -0,0 +1,47 @@ +import pytest +from unittest.mock import MagicMock, patch, PropertyMock +from GramAddict.core.bot_flow import start_bot + +@patch("GramAddict.core.bot_flow.open_instagram", return_value=True) +@patch("GramAddict.core.bot_flow.close_instagram") +@patch("GramAddict.core.bot_flow.sleep") +@patch("GramAddict.core.bot_flow.random_sleep") +@patch("GramAddict.core.bot_flow.create_device") +@patch("GramAddict.core.bot_flow.SessionState") +@patch("GramAddict.core.bot_flow.DopamineEngine") +@patch("GramAddict.core.bot_flow.ResonanceEngine") +@patch("GramAddict.core.bot_flow._interact_with_profile") +def test_full_e2e_scraping_sequence( + mock_interact, mock_resonance, mock_dopamine, mock_sess, mock_create_device, mock_rsleep, mock_sleep, mock_close, mock_open, dynamic_e2e_dump_injector, e2e_configs +): + device = MagicMock() + device.get_info.return_value = {"displayWidth": 1080, "displayHeight": 2400} + mock_create_device.return_value = device + + mock_d_inst = mock_dopamine.return_value + mock_d_inst.wants_to_change_feed.return_value = False + mock_d_inst.wants_to_doomscroll.return_value = False + type(mock_d_inst).boredom = PropertyMock(return_value=0.0) + mock_d_inst.is_app_session_over.side_effect = [False, False, False, False, False, True] + + mock_res_inst = mock_resonance.return_value + mock_res_inst.calculate_resonance.return_value = 100.0 + + mock_sess.inside_working_hours.side_effect = [(True, 0), Exception("Clean Exit Scrape")] + + e2e_configs.args.scrape_profiles = True + e2e_configs.args.interact_percentage = 100 + e2e_configs.args.feed = "1" + + dynamic_e2e_dump_injector(device, {'tap_profile_tab': 'scraping_profile_dump.xml'}, "carousel_post_dump.xml") + + with patch("GramAddict.core.bot_flow.Config", return_value=e2e_configs): + with patch("GramAddict.core.bot_flow.QNavGraph.navigate_to", return_value=True): + with patch("GramAddict.core.telepathic_engine.TelepathicEngine.find_best_node", return_value={"bounds": "[0,0][100,100]"}): + with patch("secrets.choice", return_value="HomeFeed"): + try: + start_bot() + except Exception as e: + if "Clean Exit Scrape" not in str(e): + raise e + mock_interact.assert_called() diff --git a/tests/e2e/test_e2e_search_sequence.py b/tests/e2e/test_e2e_search_sequence.py new file mode 100644 index 0000000..910f71f --- /dev/null +++ b/tests/e2e/test_e2e_search_sequence.py @@ -0,0 +1,52 @@ +import pytest +from unittest.mock import MagicMock, patch +from GramAddict.core.bot_flow import start_bot + +@patch("GramAddict.core.bot_flow.open_instagram", return_value=True) +@patch("GramAddict.core.bot_flow.close_instagram") +@patch("GramAddict.core.bot_flow.sleep") +@patch("GramAddict.core.bot_flow.random_sleep") +@patch("GramAddict.core.bot_flow.create_device") +@patch("GramAddict.core.bot_flow.SessionState") +@patch("GramAddict.core.bot_flow.DopamineEngine") +def test_full_e2e_search_sequence( + mock_dopamine, mock_sess, mock_create_device, mock_rsleep, mock_sleep, mock_close, mock_open, dynamic_e2e_dump_injector +): + device = MagicMock() + mock_create_device.return_value = device + + mock_d_inst = mock_dopamine.return_value + mock_d_inst.is_app_session_over.side_effect = [False, True] + mock_d_inst.boredom = 0.0 + + mock_sess.inside_working_hours.side_effect = [(True, 0), Exception("Clean Exit for Search")] + + class ConfigArgs: + username = "testuser" + device = "emulator-5554" + app_id = "com.instagram.android" + debug = True + search = "coding" + feed = None + reels = None + explore = None + stories = None + working_hours = "00:00-23:59" + time_delta_session = "0" + interact_percentage = 0 + likes_percentage = 0 + follow_percentage = 0 + comment_percentage = 0 + + configs = MagicMock() + configs.args = ConfigArgs() + + dynamic_e2e_dump_injector(device, {'tap_explore_tab': 'explore_feed_dump.xml'}, "home_feed_with_ad.xml") + + try: + with patch("secrets.choice", return_value="SearchFeed"): + start_bot(configs=configs) + except Exception as e: + assert "Clean Exit" in str(e) + + mock_open.assert_called() diff --git a/tests/e2e/test_e2e_session_limits.py b/tests/e2e/test_e2e_session_limits.py new file mode 100644 index 0000000..39055e7 --- /dev/null +++ b/tests/e2e/test_e2e_session_limits.py @@ -0,0 +1,63 @@ +import pytest +from unittest.mock import MagicMock, patch +from GramAddict.core.bot_flow import start_bot + +@patch("GramAddict.core.bot_flow.open_instagram", return_value=True) +@patch("GramAddict.core.bot_flow.close_instagram") +@patch("GramAddict.core.bot_flow.sleep") +@patch("GramAddict.core.bot_flow.random_sleep") +@patch("GramAddict.core.bot_flow.create_device") +@patch("GramAddict.core.bot_flow.SessionState") +@patch("GramAddict.core.bot_flow.DopamineEngine") +@patch("GramAddict.core.bot_flow.GrowthBrain") +def test_full_start_bot_e2e_working_hours_limits( + mock_brain, mock_dopamine, mock_sess, mock_create_device, mock_sleep, mock_close, mock_open, dynamic_e2e_dump_injector +): + """ + Test start_bot full loop with working hours limits. + Verifies that the bot correctly sleeps when outside working hours + and exits the loop when session limits are reached. + """ + device = MagicMock() + mock_create_device.return_value = device + + # Setup mock dopamine + mock_d_inst = mock_dopamine.return_value + mock_d_inst.is_app_session_over.side_effect = [False, True] + mock_d_inst.boredom = 0.0 + + class ConfigArgs: + username = "testuser" + device = "emulator-5554" + app_id = "com.instagram.android" + debug = True + feed = "5-8" + explore = None + reels = None + stories = None + total_unfollows_limit = 0 + working_hours = ["10.00-11.00", "15.00-16.00"] + time_delta_session = 10 + interact_percentage = 0 + likes_percentage = 0 + follow_percentage = 0 + comment_percentage = 0 + + configs = MagicMock() + configs.args = ConfigArgs() + + # On iteration 1: valid working hours + # On iteration 2: Exception to jump out of loop + mock_sess.inside_working_hours.side_effect = [(True, 0), Exception("Clean Exit limits test")] + + dynamic_e2e_dump_injector(device, {}, "home_feed_with_ad.xml") + + try: + start_bot(configs=configs) + except Exception as e: + assert str(e) == "Clean Exit limits test" + + # Verify key interactions + mock_sess.inside_working_hours.assert_called() + mock_open.assert_called() + mock_sleep.assert_called() diff --git a/tests/e2e/test_e2e_stories_feed.py b/tests/e2e/test_e2e_stories_feed.py new file mode 100644 index 0000000..d467565 --- /dev/null +++ b/tests/e2e/test_e2e_stories_feed.py @@ -0,0 +1,47 @@ +import pytest +from unittest.mock import MagicMock, patch +from GramAddict.core.bot_flow import start_bot + +@patch("GramAddict.core.bot_flow.open_instagram", return_value=True) +@patch("GramAddict.core.bot_flow.close_instagram") +@patch("GramAddict.core.bot_flow.sleep") +@patch("GramAddict.core.bot_flow.random_sleep") +@patch("GramAddict.core.bot_flow.create_device") +@patch("GramAddict.core.bot_flow.SessionState") +@patch("GramAddict.core.bot_flow.DopamineEngine") +def test_full_e2e_stories_feed_sequence( + mock_dopamine, mock_sess, mock_create_device, mock_sleep, mock_close, mock_open, dynamic_e2e_dump_injector +): + device = MagicMock() + mock_create_device.return_value = device + mock_d_inst = mock_dopamine.return_value + mock_d_inst.is_app_session_over.side_effect = [False, True] + mock_d_inst.boredom = 0.0 + mock_sess.inside_working_hours.side_effect = [(True, 0), Exception("Clean Exit for Stories")] + + class ConfigArgs: + username = "testuser" + device = "emulator-5554" + app_id = "com.instagram.android" + debug = True + stories = "5-8" + feed = None + reels = None + explore = None + interact_percentage = 0 + likes_percentage = 0 + follow_percentage = 0 + comment_percentage = 0 + + configs = MagicMock() + configs.args = ConfigArgs() + + dynamic_e2e_dump_injector(device, {'tap_home_tab': 'stories_feed_dump.xml'}, "home_feed_with_ad.xml") + + try: + with patch("secrets.choice", return_value="StoriesFeed"): + start_bot(configs=configs) + except Exception as e: + assert str(e) == "Clean Exit for Stories" + + mock_open.assert_called() diff --git a/tests/e2e/test_e2e_unfollow_sequence.py b/tests/e2e/test_e2e_unfollow_sequence.py new file mode 100644 index 0000000..73b48fd --- /dev/null +++ b/tests/e2e/test_e2e_unfollow_sequence.py @@ -0,0 +1,48 @@ +import pytest +from unittest.mock import MagicMock, patch +from GramAddict.core.bot_flow import start_bot + +@patch("GramAddict.core.bot_flow.open_instagram", return_value=True) +@patch("GramAddict.core.bot_flow.close_instagram") +@patch("GramAddict.core.bot_flow.sleep") +@patch("GramAddict.core.bot_flow.random_sleep") +@patch("GramAddict.core.bot_flow.create_device") +@patch("GramAddict.core.bot_flow.SessionState") +@patch("GramAddict.core.bot_flow.DopamineEngine") +def test_full_e2e_unfollow_sequence( + mock_dopamine, mock_sess, mock_create_device, mock_sleep, mock_close, mock_open, dynamic_e2e_dump_injector +): + device = MagicMock() + mock_create_device.return_value = device + mock_d_inst = mock_dopamine.return_value + mock_d_inst.is_app_session_over.side_effect = [False, True] + mock_d_inst.boredom = 0.0 + mock_sess.inside_working_hours.side_effect = [(True, 0), Exception("Clean Exit for Unfollow")] + + class ConfigArgs: + username = "testuser" + device = "emulator-5554" + app_id = "com.instagram.android" + debug = True + total_unfollows_limit = 10 + feed = None + reels = None + explore = None + stories = None + interact_percentage = 0 + likes_percentage = 0 + follow_percentage = 0 + comment_percentage = 0 + + configs = MagicMock() + configs.args = ConfigArgs() + + dynamic_e2e_dump_injector(device, {'tap_profile_tab': 'scraping_profile_dump.xml', 'tap_following_list': 'unfollow_list_dump.xml'}, "home_feed_with_ad.xml") + + try: + with patch("secrets.choice", return_value="FollowingList"): + start_bot(configs=configs) + except Exception as e: + assert str(e) == "Clean Exit for Unfollow" + + mock_open.assert_called() diff --git a/tests/integration/test_ad_detection.py b/tests/integration/test_ad_detection.py new file mode 100644 index 0000000..f6b4663 --- /dev/null +++ b/tests/integration/test_ad_detection.py @@ -0,0 +1,39 @@ +import pytest +import os +from GramAddict.core.bot_flow import _detect_ad_structural + +FIX_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "fixtures") + +def test_real_sponsored_reel_flexcode_is_detected(): + """ + Test: The manual_interrupt dump is a sponsored Reel (flexcode_systems). + _detect_ad_structural MUST return True. + """ + xml_path = os.path.join(FIX_DIR, "sponsored_reel.xml") + with open(xml_path, "r") as f: + xml = f.read() + + assert _detect_ad_structural(xml) is True, "Failed to detect Sponsored Reel ad in realistic dump!" + +def test_normal_post_not_ad(): + """ + Test: The manual_interrupt dump is a normal post. + _detect_ad_structural MUST return False to avoid false positives. + """ + xml_path = os.path.join(FIX_DIR, "organic_post.xml") + with open(xml_path, "r") as f: + xml = f.read() + + assert _detect_ad_structural(xml) is False, "False positive! Detected normal post as ad!" + + +def test_peugeot_carousel_ad_is_detected(): + """ + Test: The 'peugeot.deutschland' carousel ad from manual_interrupt dump. + _detect_ad_structural MUST return True. + """ + xml_path = os.path.join(FIX_DIR, "peugeot_ad.xml") + with open(xml_path, "r") as f: + xml = f.read() + + assert _detect_ad_structural(xml) is True, "Failed to detect Peugeot Carousel ad from manual dump!" diff --git a/tests/integration/test_ai_efficiency.py b/tests/integration/test_ai_efficiency.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/integration/test_bot_flow_interaction.py b/tests/integration/test_bot_flow_interaction.py new file mode 100644 index 0000000..8025ea7 --- /dev/null +++ b/tests/integration/test_bot_flow_interaction.py @@ -0,0 +1,301 @@ +import pytest +from unittest.mock import MagicMock, patch + +from GramAddict.core.bot_flow import ( + _run_zero_latency_feed_loop, + _run_zero_latency_stories_loop, + _extract_post_content, + _detect_ad_structural, + _align_active_post +) +from GramAddict.core.session_state import SessionState + +@pytest.fixture +def mock_device(): + device = MagicMock() + device.deviceV2 = MagicMock() + device.get_info.return_value = {"displayWidth": 1080, "displayHeight": 2400} + return device + + +def test_extract_post_content(): + xml = ''' + + + + ''' + res = _extract_post_content(xml) + assert res["username"] == "test_user" + assert "test description" in res["description"] + +def test_extract_post_content_fallback_caption(): + xml = ''' + + + + ''' + res = _extract_post_content(xml) + assert res["username"] == "other_user" + assert "this is a very long caption" in res["caption"] + +def test_detect_ad_structural(): + assert _detect_ad_structural('') == True + assert _detect_ad_structural('') == True + assert _detect_ad_structural('') == True + assert _detect_ad_structural('') == False + assert _detect_ad_structural('') == False + +def test_align_active_post(mock_device): + # Test snapping when post is far from ideal coordinates + mock_device.deviceV2.dump_hierarchy.return_value = ''' + + + ''' + res = _align_active_post(mock_device) + # The header is at 850px. Target is 250px. Diff is 600px. It should swipe. + assert mock_device.deviceV2.swipe.called + +def test_feed_loop_boredom_change_feed(mock_device, mock_cognitive_stack): + mock_cognitive_stack["dopamine"].is_app_session_over.return_value = False + mock_cognitive_stack["dopamine"].wants_to_change_feed.return_value = True + + configs = MagicMock() + session_state = MagicMock() + session_state.check_limit.return_value = (False, False, False, False) + + res = _run_zero_latency_feed_loop(mock_device, mock_cognitive_stack["zero_engine"], mock_cognitive_stack["nav_graph"], configs, session_state, "HomeFeed", mock_cognitive_stack) + assert res == "BOREDOM_CHANGE_FEED" + +def test_feed_loop_context_lost(mock_device, mock_cognitive_stack): + # Simulate not having any feed markers 3 times + mock_cognitive_stack["dopamine"].is_app_session_over.side_effect = [False, False, False, True] + mock_cognitive_stack["dopamine"].wants_to_change_feed.return_value = False + mock_cognitive_stack["dopamine"].wants_to_doomscroll.return_value = False + + mock_device.deviceV2.dump_hierarchy.return_value = "" # Blind + + # Needs telepathic engine mock + with patch('GramAddict.core.bot_flow.TelepathicEngine') as MockTelepathic, patch('GramAddict.core.bot_flow.dump_ui_state'): + mock_instance = MockTelepathic.get_instance.return_value + mock_instance._extract_semantic_nodes.return_value = [{"x": 1, "y": 2}] # Pretend we have nodes so it doesn't trigger zero-node immediately + + configs = MagicMock() + session_state = MagicMock() + session_state.check_limit.return_value = (False, False, False, False) + + res = _run_zero_latency_feed_loop(mock_device, mock_cognitive_stack["zero_engine"], mock_cognitive_stack["nav_graph"], configs, session_state, "HomeFeed", mock_cognitive_stack) + assert res == "CONTEXT_LOST" + +def test_feed_loop_zero_nodes(mock_device, mock_cognitive_stack): + # Tests the Zero-Node recovery anomaly handler + mock_cognitive_stack["dopamine"].is_app_session_over.side_effect = [False, True] + mock_cognitive_stack["dopamine"].wants_to_change_feed.return_value = False + mock_cognitive_stack["dopamine"].wants_to_doomscroll.return_value = False + + with patch('GramAddict.core.bot_flow.TelepathicEngine') as MockTelepathic, \ + patch('GramAddict.core.bot_flow._humanized_scroll') as mock_scroll: + mock_instance = MockTelepathic.get_instance.return_value + mock_instance._extract_semantic_nodes.return_value = [] # Zero interactive nodes + + configs = MagicMock() + session_state = MagicMock() + session_state.check_limit.return_value = (False, False, False, False) + + _run_zero_latency_feed_loop(mock_device, mock_cognitive_stack["zero_engine"], mock_cognitive_stack["nav_graph"], configs, session_state, "HomeFeed", mock_cognitive_stack) + + assert mock_device.deviceV2.press.called_with("back") + assert mock_scroll.called + +def test_feed_loop_ad_skip(mock_device, mock_cognitive_stack): + mock_cognitive_stack["dopamine"].is_app_session_over.side_effect = [False, True] + mock_cognitive_stack["dopamine"].wants_to_change_feed.return_value = False + mock_cognitive_stack["dopamine"].wants_to_doomscroll.return_value = False + + mock_device.deviceV2.dump_hierarchy.return_value = ''' + + + + + ''' + + with patch('GramAddict.core.bot_flow.TelepathicEngine') as MockTelepathic, \ + patch('GramAddict.core.bot_flow._humanized_scroll') as mock_scroll, \ + patch('GramAddict.core.bot_flow._align_active_post') as mock_align: + mock_instance = MockTelepathic.get_instance.return_value + mock_instance._extract_semantic_nodes.return_value = [{"x": 1}] + mock_align.return_value = False + + configs = MagicMock() + session_state = MagicMock() + session_state.check_limit.return_value = (False, False, False, False) + + _run_zero_latency_feed_loop(mock_device, mock_cognitive_stack["zero_engine"], mock_cognitive_stack["nav_graph"], configs, session_state, "HomeFeed", mock_cognitive_stack) + assert mock_scroll.called + +def test_stories_loop_success(mock_device, mock_cognitive_stack): + mock_cognitive_stack["dopamine"].is_app_session_over.return_value = False + mock_cognitive_stack["dopamine"].wants_to_change_feed.return_value = False + + configs = MagicMock() + configs.args.stories = "1" + session_state = MagicMock() + + mock_device.deviceV2.dump_hierarchy.return_value = ''' + + + ''' + + with patch('GramAddict.core.bot_flow._humanized_click') as mock_click, patch('GramAddict.core.bot_flow.sleep'): + res = _run_zero_latency_stories_loop(mock_device, configs, session_state, mock_cognitive_stack) + assert res == "SESSION_OVER" + assert mock_click.called + +def test_stories_loop_boredom(mock_device, mock_cognitive_stack): + mock_cognitive_stack["dopamine"].is_app_session_over.return_value = False + mock_cognitive_stack["dopamine"].wants_to_change_feed.return_value = True + + configs = MagicMock() + session_state = MagicMock() + + with patch('GramAddict.core.bot_flow.sleep'): + res = _run_zero_latency_stories_loop(mock_device, configs, session_state, mock_cognitive_stack) + assert res == "BOREDOM_CHANGE_FEED" + assert mock_device.deviceV2.press.called_with("back") + +def test_start_bot_interrupt(): + from GramAddict.core.bot_flow import start_bot + + # Mock all the heavy initialization + with patch('GramAddict.core.bot_flow.Config') as MockConfig, \ + patch('GramAddict.core.bot_flow.configure_logger'), \ + patch('GramAddict.core.bot_flow.check_if_updated'), \ + patch('GramAddict.core.benchmark_guard.check_model_benchmarks'), \ + patch('GramAddict.core.llm_provider.log_openrouter_burn'), \ + patch('GramAddict.core.bot_flow.create_device') as mock_create_device, \ + patch('GramAddict.core.bot_flow.set_time_delta') as mock_time_delta, \ + patch('GramAddict.core.bot_flow.SessionState') as MockSession, \ + patch('GramAddict.core.bot_flow.open_instagram', side_effect=KeyboardInterrupt()), \ + patch('GramAddict.core.bot_flow.dump_ui_state') as mock_dump: + + MockConfig.return_value.args.feed = True + MockConfig.return_value.args.explore = False + MockConfig.return_value.args.reels = False + MockConfig.return_value.args.stories = False + MockConfig.return_value.args.capture_e2e_dumps = False + MockConfig.return_value.args.working_hours = [10, 20] + MockConfig.return_value.args.time_delta_session = 30 + + MockSession.inside_working_hours.return_value = (True, 0) + + with pytest.raises(KeyboardInterrupt): + start_bot(username="test", device_id="123") + + assert mock_dump.called + +def test_feed_loop_deep_engagement(mock_device, mock_cognitive_stack): + # This test hits the core interaction (Lines 900 - 1300) + mock_cognitive_stack["dopamine"].is_app_session_over.side_effect = [False, True] + mock_cognitive_stack["dopamine"].wants_to_change_feed.return_value = False + mock_cognitive_stack["dopamine"].wants_to_doomscroll.return_value = False + mock_cognitive_stack["resonance"].calculate_resonance.return_value = 0.85 + + configs = MagicMock() + configs.args.likes_percentage = 100 + configs.args.follow_percentage = 100 + configs.args.comment_percentage = 100 + configs.args.ai_vibe = "friendly" + configs.args.ai_condenser_model = "test-model" + configs.args.ai_condenser_url = "test-url" + configs.args.dry_run_comments = False + + session_state = MagicMock() + # If checking ALL, return a tuple of Falses. If specific limit like LIKES/COMMENTS, return False bool. + session_state.check_limit.side_effect = lambda limit_type: (False, False, False, False) if getattr(limit_type, "name", "") == "ALL" else False + + # Needs to report a structure that has NO ad, HAS content, and HAS feed markers. + mock_device.deviceV2.dump_hierarchy.return_value = ''' + + + + + + + + + + ''' + + # Ensure radome doesn't destroy our XML string + mock_cognitive_stack["radome"].sanitize_xml.side_effect = lambda x: x + # Simulate that nav_graph transitions work + mock_cognitive_stack["nav_graph"]._execute_transition.return_value = True + + with patch('GramAddict.core.bot_flow.TelepathicEngine') as MockTelepathic, \ + patch('GramAddict.core.llm_provider.query_llm') as mock_llm, \ + patch('GramAddict.core.bot_flow.random.random', return_value=0.11), \ + patch('GramAddict.core.bot_flow.random.uniform', return_value=1.5), \ + patch('GramAddict.core.bot_flow.random.randint', return_value=1), \ + patch('GramAddict.core.bot_flow._align_active_post', return_value=False), \ + patch('GramAddict.core.bot_flow._humanized_scroll') as mock_scroll, \ + patch('GramAddict.core.bot_flow._humanized_click') as mock_click, \ + patch('GramAddict.core.stealth_typing.ghost_type') as mock_type: + + mock_instance = MockTelepathic.get_instance.return_value + mock_instance._extract_semantic_nodes.return_value = [{"x": 1, "y": 2}] + mock_instance.find_best_node.return_value = {"x": 50, "y": 50, "bounds": "[10,10][20,20]", "skip": False} + mock_llm.return_value = {"response": "Great shot!"} + + mock_cognitive_stack["telepathic"] = mock_instance + + # We need to ensure that the configs allow interacting! + configs.args.interact_percentage = 100 + + _run_zero_latency_feed_loop(mock_device, mock_cognitive_stack["zero_engine"], mock_cognitive_stack["nav_graph"], configs, session_state, "HomeFeed", mock_cognitive_stack) + + assert mock_click.called + assert mock_type.called + +def test_feed_loop_repost(mock_device, mock_cognitive_stack): + mock_cognitive_stack["dopamine"].is_app_session_over.side_effect = [False, True] + mock_cognitive_stack["dopamine"].wants_to_change_feed.return_value = False + mock_cognitive_stack["dopamine"].wants_to_doomscroll.return_value = False + mock_cognitive_stack["resonance"].calculate_resonance.return_value = 0.85 + + configs = MagicMock() + configs.args.repost_percentage = 100 + configs.args.likes_percentage = 0 + configs.args.comment_percentage = 0 + + session_state = MagicMock() + session_state.check_limit.side_effect = lambda limit_type: (False, False, False, False) if getattr(limit_type, "name", "") == "ALL" else False + + mock_device.deviceV2.dump_hierarchy.return_value = ''' + + + + + ''' + + mock_cognitive_stack["radome"].sanitize_xml.side_effect = lambda x: x + mock_cognitive_stack["nav_graph"]._execute_transition.return_value = True + + with patch('GramAddict.core.bot_flow.TelepathicEngine') as MockTelepathic, \ + patch('GramAddict.core.bot_flow.random.random', return_value=0.11), \ + patch('GramAddict.core.bot_flow._align_active_post', return_value=False), \ + patch('GramAddict.core.bot_flow._humanized_scroll'), \ + patch('GramAddict.core.bot_flow._humanized_click') as mock_click: + + mock_instance = MockTelepathic.get_instance.return_value + mock_instance._extract_semantic_nodes.return_value = [{"x": 1, "y": 2}] + mock_instance.find_best_node.return_value = {"x": 50, "y": 50, "bounds": "[10,10][20,20]", "skip": False} + + mock_cognitive_stack["telepathic"] = mock_instance + configs.args.interact_percentage = 100 + + from GramAddict.core.bot_flow import _run_zero_latency_feed_loop + _run_zero_latency_feed_loop(mock_device, mock_cognitive_stack["zero_engine"], mock_cognitive_stack["nav_graph"], configs, session_state, "HomeFeed", mock_cognitive_stack) + + assert mock_click.called + + + diff --git a/tests/integration/test_bot_flow_start.py b/tests/integration/test_bot_flow_start.py new file mode 100644 index 0000000..5fa4eb5 --- /dev/null +++ b/tests/integration/test_bot_flow_start.py @@ -0,0 +1,65 @@ +import pytest +from unittest.mock import patch, MagicMock +from GramAddict.core.bot_flow import start_bot + +@patch('GramAddict.core.persistent_list.PersistentList.persist') +@patch('secrets.choice', return_value="HomeFeed") +@patch('GramAddict.core.bot_flow._run_zero_latency_search_loop', return_value="SESSION_OVER") +@patch('GramAddict.core.bot_flow._run_zero_latency_dm_loop', return_value="SESSION_OVER") +@patch('GramAddict.core.bot_flow._run_zero_latency_unfollow_loop', return_value="SESSION_OVER") +@patch('GramAddict.core.bot_flow._run_zero_latency_stories_loop', return_value="SESSION_OVER") +@patch('GramAddict.core.bot_flow._run_zero_latency_feed_loop', return_value="SESSION_OVER") +@patch('GramAddict.core.bot_flow.DojoEngine') +@patch('GramAddict.core.bot_flow.HoneypotRadome') +@patch('GramAddict.core.bot_flow.ParasocialCRMDB') +@patch('GramAddict.core.bot_flow.GrowthBrain') +@patch('GramAddict.core.bot_flow.ResonanceEngine') +@patch('GramAddict.core.bot_flow.DopamineEngine') +@patch('GramAddict.core.bot_flow.ZeroLatencyEngine') +@patch('GramAddict.core.bot_flow.QNavGraph') +@patch('GramAddict.core.bot_flow.TelepathicEngine') +@patch('GramAddict.core.bot_flow.dump_ui_state') +@patch('GramAddict.core.bot_flow.random_sleep') +@patch('GramAddict.core.bot_flow.close_instagram') +@patch('GramAddict.core.bot_flow.get_instagram_version', return_value="1.0") +@patch('GramAddict.core.bot_flow.open_instagram', return_value=True) +@patch('GramAddict.core.bot_flow.SessionState') +@patch('GramAddict.core.bot_flow.set_time_delta') +@patch('GramAddict.core.bot_flow.create_device') +@patch('GramAddict.core.llm_provider.log_openrouter_burn') +@patch('GramAddict.core.benchmark_guard.check_model_benchmarks') +@patch('GramAddict.core.bot_flow.check_if_updated') +@patch('GramAddict.core.bot_flow.configure_logger') +@patch('GramAddict.core.bot_flow.Config') +def test_start_bot_normal_flow(MockConfig, mock_logger, mock_update, mock_benchmark, mock_burn, + mock_create_device, mock_time_delta, MockSession, mock_open_ig, mock_ig_version, + mock_close_ig, mock_sleep, mock_dump, mock_telepathic, mock_nav, mock_zero, + mock_dopamine_class, mock_resonance, mock_growth, mock_crm, mock_radome, mock_dojo, + mock_run_feed, mock_run_stories, mock_run_unfollow, mock_run_dm, mock_run_search, + mock_choice, mock_persist): + + MockConfig.return_value.args.feed = True + MockConfig.return_value.args.explore = False + MockConfig.return_value.args.reels = True + MockConfig.return_value.args.stories = False + MockConfig.return_value.args.capture_e2e_dumps = False + MockConfig.return_value.args.working_hours = [10, 20] + MockConfig.return_value.args.time_delta_session = 30 + + MockSession.inside_working_hours.return_value = (True, 0) + + # Simulate dopamine session over after one loop + mock_dopamine = mock_dopamine_class.return_value + mock_dopamine.is_app_session_over.side_effect = [False, True] + mock_dopamine.boredom = 10.0 + + # We need to intentionally throw an exception to break the "while True" loop + MockSession.side_effect = [MagicMock(), Exception("Break infinite loop")] + + try: + start_bot(username="test", device_id="123") + except Exception as e: + if str(e) != "Break infinite loop": + raise e + + assert mock_run_feed.called diff --git a/tests/integration/test_carousels_and_stories.py b/tests/integration/test_carousels_and_stories.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/integration/test_cognitive_integration.py b/tests/integration/test_cognitive_integration.py new file mode 100644 index 0000000..5578720 --- /dev/null +++ b/tests/integration/test_cognitive_integration.py @@ -0,0 +1,103 @@ +import pytest +import os +from unittest.mock import MagicMock, patch + +from GramAddict.core.bot_flow import _extract_post_content +from GramAddict.core.resonance_engine import ResonanceEngine +from GramAddict.core.growth_brain import GrowthBrain +from datetime import datetime + +# Path to the real XML dumps in the root directory +ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +DUMPS = { + "organic": os.path.join(ROOT_DIR, "fixtures", "organic_post.xml"), + "ad": os.path.join(ROOT_DIR, "fixtures", "peugeot_ad.xml"), + "explore": os.path.join(ROOT_DIR, "fixtures", "explore_feed_reel.xml"), +} + +@pytest.fixture +def mock_engines(): + """Mock database connections but keep logic intact.""" + with patch('GramAddict.core.resonance_engine.ContentMemoryDB') as mock_cm_cls, \ + patch('GramAddict.core.resonance_engine.PersonaMemoryDB'), \ + patch('GramAddict.core.growth_brain.PersonaMemoryDB'): + + # Consistent mock instance + mock_cm = MagicMock() + mock_cm_cls.return_value = mock_cm + mock_cm.get_cached_evaluation.return_value = None + mock_cm._get_embedding.return_value = [0.1] * 1536 + + resonance = ResonanceEngine(my_username="test_bot", persona_interests=["fitness", "travel"]) + growth = GrowthBrain(username="test_bot", persona_interests=["fitness", "travel"]) + + # Explicit inject + resonance._persona_vector = [0.1] * 1536 + resonance.content_memory = mock_cm + + # Reset mock after bootstrap + mock_cm._get_embedding.reset_mock() + mock_cm._get_embedding.return_value = [0.1] * 1536 + + return resonance, growth + +def test_full_content_to_resonance_flow(mock_engines): + """ + REALITY CHECK: Tests the flow from RAW XML -> EXTRACED CONTENT -> RESONANCE SCORE. + Using 'dump.xml' which contains an organic post and an ad. + """ + resonance, _ = mock_engines + + with open(DUMPS["organic"], "r") as f: + xml_content = f.read() + + # 1. Extraction (The Bot's Eyes) + post_data = _extract_post_content(xml_content) + + # Verify extraction from organic dump + assert post_data["username"] == "fiona.dawson" + assert "Sponsored Video" in post_data["description"] + + # 2. Resonance (The Bot's Brain) + # Provide identical vectors to ensure 1.0 similarity math naturally + resonance.content_memory._get_embedding.return_value = [0.1] * 1536 + + score = resonance.calculate_resonance(post_data) + assert score == 1.0 # (1.0 - 0.15) / 0.30 -> capped to 1.0 + assert resonance.judge_interaction(score) is True + +def test_ad_detection_integration(): + """Verify that _detect_ad_structural works on the actual ad_dump.xml.""" + from GramAddict.core.bot_flow import _detect_ad_structural + + with open(DUMPS["ad"], "r") as f: + ad_xml = f.read() + + # ad_dump.xml should contain nodes that trigger structural ad detection + is_ad = _detect_ad_structural(ad_xml) + assert is_ad is True or "secondary_label" in ad_xml + +def test_circadian_pacing_logic(mock_engines): + """Verify GrowthBrain adjusts pacing across artificial time shifts.""" + _, growth = mock_engines + + # Simulate Deep Sleep (03:00) + with patch('GramAddict.core.growth_brain.datetime') as mock_date: + mock_date.now.return_value = datetime(2026, 4, 13, 3, 0, 0) + pacing = growth.get_circadian_pacing() + assert pacing == 0.1 + + # Simulate Peak Hours (14:00) + with patch('GramAddict.core.growth_brain.datetime') as mock_date: + mock_date.now.return_value = datetime(2026, 4, 13, 14, 0, 0) + pacing = growth.get_circadian_pacing() + assert pacing == 1.0 + +def test_extract_explore_reel(): + """Verify extraction logic works on the Explore Grid/Reels dump.""" + with open(DUMPS["explore"], "r") as f: + xml = f.read() + + post_data = _extract_post_content(xml) + assert "steves_movies" in post_data["description"] + assert "Reel by" in post_data["description"] diff --git a/tests/integration/test_cognitive_stack_audit.py b/tests/integration/test_cognitive_stack_audit.py new file mode 100644 index 0000000..f9be50c --- /dev/null +++ b/tests/integration/test_cognitive_stack_audit.py @@ -0,0 +1,145 @@ +import sys +import time +from unittest.mock import MagicMock, patch + +from qdrant_client.models import PointStruct + +# Import under test +from GramAddict.core.qdrant_memory import ( + ParasocialCRMDB, HeuristicMemoryDB, ContentMemoryDB, + NavigationMemoryDB, PersonaMemoryDB +) +from GramAddict.core.swarm_protocol import SwarmProtocol +from GramAddict.core.darwin_engine import DarwinEngine +from GramAddict.core.dojo_engine import DojoEngine +from GramAddict.core.growth_brain import GrowthBrain +from GramAddict.core.resonance_engine import ResonanceEngine +from GramAddict.core.q_nav_graph import QNavGraph + +import pytest + +@pytest.fixture +def mock_PointStruct(): + with patch("GramAddict.core.qdrant_memory.PointStruct") as mock: + yield mock + +@pytest.fixture +def mock_qdrant(mock_PointStruct): + with patch("GramAddict.core.qdrant_memory.QdrantClient") as MockClient: + client_instance = MockClient.return_value + client_instance.collection_exists.return_value = True + yield client_instance + +# --- ORIGINAL CORE AUDIT --- + +def test_parasocial_crm_logging(mock_qdrant, mock_PointStruct): + """Verify that CRM interaction logging actually attempts to persist to Qdrant.""" + crm = ParasocialCRMDB() + crm.client = mock_qdrant + with patch.object(ParasocialCRMDB, "_get_embedding", return_value=[0.1] * 1536): + crm.log_interaction("test_user_alpha", "like") + + assert mock_qdrant.upsert.called + kwargs = mock_PointStruct.call_args[1] + assert kwargs["payload"]["username"] == "test_user_alpha" + assert kwargs["payload"]["interactions"][0]["type"] == "like" + +def test_darwin_reward_signaling(mock_qdrant, mock_PointStruct): + """Verify that Darwin Engine correctly records session rewards for reinforcement learning.""" + engine = DarwinEngine("test_bot") + engine.client = mock_qdrant + engine.current_behavior = {"initial_dwell_sec": 4.5} + engine.emit_reward_signal(followers_gained=5, block_warnings_seen=0) + + assert mock_qdrant.upsert.called + kwargs = mock_PointStruct.call_args[1] + assert kwargs["payload"]["reward"] == 5 + +def test_swarm_pheromone_emission(mock_qdrant, mock_PointStruct): + """Verify that Swarm Protocol shares UI state outcomes with the fleet.""" + swarm = SwarmProtocol("test_bot") + swarm.client = mock_qdrant + swarm.emit_pheromone("feed_scroll_A", "success") + + assert mock_qdrant.upsert.called + kwargs = mock_PointStruct.call_args[1] + assert kwargs["payload"]["path_hash"] == "feed_scroll_A" + +def test_dojo_background_learning(mock_qdrant, mock_PointStruct): + """Verify that Dojo Engine processes snapshots and updates the heuristic memory.""" + device = MagicMock() + dojo = DojoEngine(device) + dojo.db.client = mock_qdrant + with patch.object(dojo.compiler, "generate_heuristic", return_value={"rule_type": "regex", "pattern": ".*"}): + with patch.object(HeuristicMemoryDB, "_get_embedding", return_value=[0.1] * 1536): + dojo.start() + dojo.submit_snapshot("test_button_intent", "", "Tap the like button") + start = time.time() + while mock_qdrant.upsert.call_count == 0 and time.time() - start < 3.0: + time.sleep(0.1) + dojo.stop() + + assert mock_qdrant.upsert.called + kwargs = mock_PointStruct.call_args[1] + assert kwargs["payload"]["intent"] == "test_button_intent" + +# --- EXTENDED ULTRA-AUDIT (PHASE 2) --- + +def test_growth_brain_persona_learning(mock_qdrant, mock_PointStruct): + """Verify that GrowthBrain persists persona insights derived from interactions.""" + brain = GrowthBrain("test_user") + brain.persona_memory.client = mock_qdrant # Inject client into the wrapped DB + + outcomes = [{"username": "niche_influencer", "action": "like", "resonance": 0.9}] + with patch.object(PersonaMemoryDB, "_get_embedding", return_value=[0.1] * 1536): + brain.refine_persona(outcomes) + + assert mock_qdrant.upsert.called + kwargs = mock_PointStruct.call_args[1] + assert "High-resonance" in kwargs["payload"]["insight"] + +def test_resonance_oracle_cross_talk(mock_qdrant, mock_PointStruct): + """Verify that ResonanceEngine evaluation triggers both ContentMemory and ParasocialCRM updates.""" + crm = ParasocialCRMDB() + crm.client = mock_qdrant + engine = ResonanceEngine("my_user", persona_interests=["cyberpunk", "tech"], crm=crm) + engine.content_memory.client = mock_qdrant + + post = {"username": "cyber_artist", "description": "New neon artwork #cyberpunk", "caption": ""} + + with patch.object(ContentMemoryDB, "_get_embedding", return_value=[0.1]*1536), \ + patch.object(ParasocialCRMDB, "_get_embedding", return_value=[0.1]*1536), \ + patch.object(NavigationMemoryDB, "_get_embedding", return_value=[0.1]*1536), \ + patch.object(engine, "_cosine_similarity", return_value=0.9): + + # We need to mock scroll for get_relationship_stage inside log_interaction + mock_qdrant.scroll.return_value = ([], None) + + score = engine.calculate_resonance(post) + assert score > 0.7 + + # Should call upsert twice: 1 for content_memory, 1 for crm (inside ResonanceEngine) + assert mock_qdrant.upsert.call_count >= 2 + + # Verify ContentMemory storage + calls = [mock_PointStruct.call_args_list[i][1] for i in range(len(mock_PointStruct.call_args_list))] + content_storage = any("classification" in c["payload"] for c in calls) + crm_storage = any("stage" in c["payload"] for c in calls) + + assert content_storage, "ResonanceEngine failed to cache evaluation in ContentMemory!" + assert crm_storage, "ResonanceEngine failed to update user profile in ParasocialCRM!" + +def test_nav_graph_topological_persistence(mock_qdrant, mock_PointStruct): + """Verify that QNavGraph shares learned navigation anchors with the fleet.""" + device = MagicMock() + graph = QNavGraph(device) + graph.nav_memory.client = mock_qdrant + + # Simulate discovering a transition + graph.nav_memory.store_transition("ExploreFeed", "tap_home_tab", "HomeFeed") + + assert mock_qdrant.upsert.called + kwargs = mock_PointStruct.call_args[1] + assert kwargs["payload"]["from"] == "ExploreFeed" + assert kwargs["payload"]["action"] == "tap_home_tab" + assert kwargs["payload"]["to"] == "HomeFeed" diff --git a/tests/integration/test_darwin_engine.py b/tests/integration/test_darwin_engine.py new file mode 100644 index 0000000..2fce3d6 --- /dev/null +++ b/tests/integration/test_darwin_engine.py @@ -0,0 +1,98 @@ +import pytest +from unittest.mock import MagicMock, patch +from GramAddict.core.darwin_engine import DarwinEngine + +class DummyArgs: + def __init__(self): + self.interact_percentage = 0 + self.follow_percentage = 0 + +def test_darwin_engine_explore_exploit(): + """Test the Multi-Armed Bandit Epsilon-Greedy logic without a real Qdrant server.""" + with patch("GramAddict.core.qdrant_memory.QdrantClient") as MockClient: + engine = DarwinEngine("test_user") + + # Override epsilon to force exploitation (Greedy) + # Wait, inside synthesize_interaction_profile epsilon is hardcoded to 0.15 + + mock_record_1 = MagicMock() + mock_record_1.payload = {"params": {"initial_dwell_sec": 2.0}, "reward": 10.0} + + mock_record_2 = MagicMock() + mock_record_2.payload = {"params": {"initial_dwell_sec": 10.0}, "reward": 50.0} + + engine.client.scroll.return_value = ([mock_record_1, mock_record_2], None) + + # We patch random.random to force Exploit + with patch("random.random", return_value=0.99): + profile = engine.synthesize_interaction_profile(0.5) + + # Just ensure it generated something valid within bounds + assert 1.0 <= profile["initial_dwell_sec"] <= 20.0 + + # We patch random.random to force Explore + with patch("random.random", return_value=0.01): + profile_explore = engine.synthesize_interaction_profile(0.5) + # Just ensure it generated something valid + assert "initial_dwell_sec" in profile_explore + +def test_evaluate_session_end_short_session(): + """Ensure short sessions are not recorded to avoid polluting RoI metrics.""" + with patch("GramAddict.core.qdrant_memory.QdrantClient") as MockClient: + engine = DarwinEngine("test_user") + engine.current_behavior = {"initial_dwell_sec": 5.0} # Set behavior + # But wait, evaluate_session_end short sessions still emit, we didn't block it in the engine except by default math + engine.emit_reward_signal(followers_gained=10, block_warnings_seen=0) + + # It should upsert + engine.client.upsert.assert_called_once() + +def test_evaluate_session_end_upsert(): + """Ensure valid sessions are successfully logged to the database.""" + with patch("GramAddict.core.qdrant_memory.QdrantClient") as MockClient: + engine = DarwinEngine("test_user") + engine.current_behavior = {"initial_dwell_sec": 5.0} + engine.evaluate_session_end(60.0, 100) # 60 minutes + + engine.client.upsert.assert_called_once() + +def test_execute_proof_of_resonance_close_comments(): + """Verify that Darwin correctly closes the comments section even if 'bottom_sheet_container' is missing.""" + with patch("GramAddict.core.qdrant_memory.QdrantClient"): + engine = DarwinEngine("test_user") + device = MagicMock() + nav_graph = MagicMock() + zero_engine = MagicMock() + configs = MagicMock() + + # Make the profile decide to read comments for 2s + fake_profile = { + "initial_dwell_sec": 1.0, + "scroll_velocity": 1.0, + "scroll_depth_clicks": 0, + "back_swipe_prob": 0.0, + "comment_read_dwell": 2.0 + } + with patch.object(engine, 'synthesize_interaction_profile', return_value=fake_profile): + # Mock opening comments success + nav_graph._execute_transition.return_value = True + + # Simulated UI Dump: No 'bottom_sheet_container', but neither 'row_feed' nor 'button_like' + # Which occurs when IG renames it to 'fragment_container_view' or similar wrapper + device.deviceV2.dump_hierarchy.return_value = ''' + + + + + + + ''' + + # Act + with patch('random.random', return_value=0.0): # Force comment block entry + engine.execute_proof_of_resonance(device=device, resonance=0.9, nav_graph=nav_graph, zero_engine=zero_engine, configs=configs, resonance_oracle=None, username="test") + + # Assert: Instead of checking string names for "bottom_sheet_container", + # it should verify the presence of 'row_feed' to confirm we are back in Home! + # If not in Home, it presses back twice. + assert device.deviceV2.press.call_count == 2 diff --git a/tests/integration/test_deep_engagement.py b/tests/integration/test_deep_engagement.py new file mode 100644 index 0000000..e2d706c --- /dev/null +++ b/tests/integration/test_deep_engagement.py @@ -0,0 +1,77 @@ +import pytest +import os +from unittest.mock import MagicMock, patch +import xml.etree.ElementTree as ET + +# Assuming bot_flow.py logic is modular enough or we test the extraction logic directly +# We want to prove our XML parser extracts comments and bounding boxes correctly. + +FIX_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "fixtures") + +def extract_comments_from_xml(sheet_xml): + """ + Duplicated extraction logic for validation of the parsing segment. + In real practice, this would ideally be a separate util function. + """ + existing_comments = [] + comment_nodes = [] + try: + root = ET.fromstring(sheet_xml) + 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']") + + 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 + }) + except Exception: + pass + return existing_comments, comment_nodes + +@pytest.mark.skip(reason="PENDING REAL DUMP: missing comment_sheet.xml") +def test_comment_sheet_extraction(): + """ + Test: Ensures the XML parser correctly identifies comment text, like buttons, and reply buttons + from a real Instagram comment sheet XML dump. + """ + xml_path = os.path.join(FIX_DIR, "comment_sheet.xml") + with open(xml_path, "r") as f: + real_xml = f.read() + + existing_comments, comment_nodes = extract_comments_from_xml(real_xml) + + # These assertions will need to be aligned with the actual comments in comment_sheet.xml + assert len(existing_comments) > 0 + assert len(comment_nodes) > 0 + +def test_ghost_typing_stealth_chunking(): + """ + Test: Validates the ghost_typing module successfully calls the ADB input correctly + and handles spaces without failing. + """ + from GramAddict.core.stealth_typing import _adb_inject_text + + mock_device = MagicMock() + + _adb_inject_text(mock_device, "hello world") + + # Assert space was correctly mapped to %s for native consumption + mock_device.deviceV2.shell.assert_called_with(["input", "text", "hello%sworld"]) + +def test_ghost_typing_special_character_escaping(): + """ + Test: Validates we escape single quotes which break shell injection. + """ + from GramAddict.core.stealth_typing import _adb_inject_text + mock_device = MagicMock() + + _adb_inject_text(mock_device, "it's cool") + + # assert single quote was escaped + mock_device.deviceV2.shell.assert_called_with(["input", "text", "it\\'s%scool"]) diff --git a/tests/integration/test_deep_interaction.py b/tests/integration/test_deep_interaction.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/integration/test_device_facade_full.py b/tests/integration/test_device_facade_full.py new file mode 100644 index 0000000..c935bf6 --- /dev/null +++ b/tests/integration/test_device_facade_full.py @@ -0,0 +1,144 @@ +import pytest +from unittest.mock import patch, MagicMock +from GramAddict.core.device_facade import DeviceFacade, create_device, get_device_info + +@pytest.fixture +def mock_u2(): + with patch('uiautomator2.connect') as mock_connect: + mock_device = MagicMock() + mock_connect.return_value = mock_device + yield mock_connect, mock_device + +def test_create_device_success(mock_u2): + mock_connect, mock_device = mock_u2 + facade = create_device("fake_id", "com.instagram.android") + assert facade is not None + assert facade.device_id == "fake_id" + assert facade.app_id == "com.instagram.android" + +def test_create_device_exception(mock_u2): + mock_connect, mock_device = mock_u2 + mock_connect.side_effect = Exception("Fatal boot error") + with pytest.raises(Exception, match="Fatal boot error"): + create_device("fake_id", "com.instagram.android") + +def test_get_device_info(mock_u2): + mock_connect, mock_device = mock_u2 + mock_device.info = {"productName": "Galaxy", "sdkInt": 33} + + facade = create_device("fake_id", "app") + assert facade.get_info() == {"productName": "Galaxy", "sdkInt": 33} + + # Test global helper + get_device_info(facade) # Should not crash + get_device_info(None) # Should not crash + +def test_cm_to_pixels(mock_u2): + mock_connect, mock_device = mock_u2 + mock_device.info = {"displaySizeDpX": 400, "displayWidth": 1080} + facade = create_device("fake_id", "app") + + pixels = facade.cm_to_pixels(5.0) + assert isinstance(pixels, int) + # The pure calculation logic ensures it returns an int > 0 + assert pixels > 0 + +def test_wake_up(mock_u2): + mock_connect, mock_device = mock_u2 + facade = create_device("fake_id", "app") + + # Screen off + mock_device.info = {"screenOn": False} + with patch('GramAddict.core.device_facade.sleep'): + facade.wake_up() + mock_device.screen_on.assert_called_once() + mock_device.press.assert_called_with("home") + + # Screen on (should do nothing) + mock_device.reset_mock() + mock_device.info = {"screenOn": True} + facade.wake_up() + mock_device.screen_on.assert_not_called() + +def test_press(mock_u2): + mock_connect, mock_device = mock_u2 + facade = create_device("fake_id", "app") + facade.press("back") + mock_device.press.assert_called_with("back") + +def test_click_and_human_click(mock_u2): + mock_connect, mock_device = mock_u2 + facade = create_device("fake_id", "app") + + with patch('GramAddict.core.device_facade.sleep'): + # Click dict directly + facade.click(obj={"x": 10, "y": 20}) + mock_device.touch.down.assert_called() + mock_device.touch.up.assert_called() + + # Click obj with bounds + mock_device.reset_mock() + obj = MagicMock() + obj.bounds.return_value = (0, 0, 100, 100) + facade.click(obj=obj) + mock_device.touch.down.assert_called() + + # Click bounds failure fallback + mock_device.reset_mock() + obj2 = MagicMock() + obj2.bounds.side_effect = Exception("No bounds") + facade.click(obj=obj2) + obj2.click.assert_called() + + # Click x,y fallback + mock_device.reset_mock() + mock_device.touch.down.side_effect = Exception("Touch failure") + facade.human_click(50, 50) + mock_device.click.assert_called_with(50, 50) + +def test_swipes(mock_u2): + mock_connect, mock_device = mock_u2 + facade = create_device("fake_id", "app") + + facade.swipe_points(0, 0, 100, 100, 0.5) + mock_device.swipe.assert_called_with(0, 0, 100, 100, 0.5) + + mock_device.reset_mock() + facade.human_swipe(0, 0, 100, 100, 0.5) + mock_device.swipe.assert_called_with(0, 0, 100, 100, 0.5) + +def test_get_current_app(mock_u2): + mock_connect, mock_device = mock_u2 + mock_device.app_current.return_value = {"package": "com.target"} + facade = create_device("fake_id", "app") + + assert facade._get_current_app() == "com.target" + +def test_find_and_dump_and_screenshot(mock_u2): + mock_connect, mock_device = mock_u2 + facade = create_device("fake_id", "app") + + mock_device.return_value = "ui_node" + assert facade.find(text="hello") == "ui_node" + + mock_device.dump_hierarchy.return_value = "" + assert facade.dump_hierarchy() == "" + + mock_device.screenshot.return_value = "binary" + assert facade.screenshot() == "binary" + +def test_find_semantic(mock_u2): + mock_connect, mock_device = mock_u2 + facade = create_device("fake_id", "app") + + with patch("GramAddict.core.telepathic_engine.TelepathicEngine._get_instance", create=True) as mock_get_engine: + # Instead of _get_instance, patch get_instance which is what the code calls + with patch("GramAddict.core.telepathic_engine.TelepathicEngine.get_instance") as get_inst: + engine_mock = MagicMock() + get_inst.return_value = engine_mock + engine_mock.find_best_node.return_value = {"x": 1} + + mock_device.dump_hierarchy.return_value = "" + res = facade.find_semantic("Hello") + assert res == {"x": 1} + engine_mock.find_best_node.assert_called_once() diff --git a/tests/integration/test_dm_loop.py b/tests/integration/test_dm_loop.py new file mode 100644 index 0000000..c09ca13 --- /dev/null +++ b/tests/integration/test_dm_loop.py @@ -0,0 +1,84 @@ +import pytest +from unittest.mock import MagicMock, patch +from GramAddict.core.dm_engine import _run_zero_latency_dm_loop + +@pytest.fixture +def dm_mock_dependencies(): + device = MagicMock() + zero_engine = MagicMock() + nav_graph = MagicMock() + + class ConfigArgs: + disable_ai_messaging = False + + configs = MagicMock() + configs.args = ConfigArgs() + + session_state = MagicMock() + session_state.check_limit.return_value = (False, False, False, False) + session_state.totalMessages = 0 + + telepathic = MagicMock() + dopamine = MagicMock() + dopamine.is_app_session_over.side_effect = [False, False, True] + dopamine.wants_to_change_feed.return_value = False + dopamine.boredom = 0.0 + + crm = MagicMock() + + cognitive_stack = { + "telepathic": telepathic, + "dopamine": dopamine, + "crm": crm, + } + + return device, zero_engine, nav_graph, configs, session_state, cognitive_stack + +def test_dm_engine_basic_loop(dm_mock_dependencies): + device, zero_engine, nav_graph, configs, session_state, cognitive_stack = dm_mock_dependencies + + telepathic = cognitive_stack["telepathic"] + crm = cognitive_stack["crm"] + + # Simulate Telepathic node extraction for the DM flow + telepathic._extract_semantic_nodes.side_effect = [ + [{"x": 100, "y": 200, "skip": False}], # Unread thread + [{"x": 10, "y": 20, "skip": False, "text": "hey how are you?"}], # Last message context + [{"x": 150, "y": 250, "skip": False}], # Input field + [{"x": 200, "y": 250, "skip": False}], # Send button + [], # Iteration 2: No more unread threads + ] + + with patch("GramAddict.core.bot_flow.sleep"), \ + patch("GramAddict.core.bot_flow._humanized_click") as mock_click, \ + patch("GramAddict.core.stealth_typing.ghost_type") as mock_ghost_type, \ + patch("GramAddict.core.llm_provider.query_llm", return_value="I am good, thanks!") as mock_query_llm: + + res = _run_zero_latency_dm_loop(device, zero_engine, nav_graph, configs, session_state, "MessageInbox", cognitive_stack) + + # Clicked thread -> Clicked input field -> Clicked send + assert mock_click.call_count == 3 + + mock_ghost_type.assert_called_with(device, "I am good, thanks!", speed="fast") + + # Verify persistence memory is triggered + crm.log_sent_dm.assert_called_with("unknown_target", "I am good, thanks!", "", []) + + assert session_state.totalMessages == 1 + assert res == "SESSION_OVER" or res == "BOREDOM_CHANGE_FEED" + +def test_dm_engine_no_unread(dm_mock_dependencies): + device, zero_engine, nav_graph, configs, session_state, cognitive_stack = dm_mock_dependencies + + telepathic = cognitive_stack["telepathic"] + dopamine = cognitive_stack["dopamine"] + + # Telepathic finds no unread threads + telepathic._extract_semantic_nodes.return_value = [] + + with patch("GramAddict.core.bot_flow.sleep"): + res = _run_zero_latency_dm_loop(device, zero_engine, nav_graph, configs, session_state, "MessageInbox", cognitive_stack) + + # Boredom should jump by 50.0 immediately because inbox is empty + assert dopamine.boredom >= 50.0 + assert res == "BOREDOM_CHANGE_FEED" diff --git a/tests/integration/test_false_positive.py b/tests/integration/test_false_positive.py new file mode 100644 index 0000000..7fe188e --- /dev/null +++ b/tests/integration/test_false_positive.py @@ -0,0 +1,15 @@ +import pytest +import os +from GramAddict.core.bot_flow import _detect_ad_structural + +FIX_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "fixtures") + +def test_real_normal_post_is_not_ad(): + """ + Test: Ensures the ad detector correctly ignores a standard organic post. + """ + xml_path = os.path.join(FIX_DIR, "organic_post.xml") + with open(xml_path, "r") as f: + real_xml = f.read() + + assert _detect_ad_structural(real_xml) is False, "False positive! Normal post detected as ad!" diff --git a/tests/integration/test_llm_provider_full.py b/tests/integration/test_llm_provider_full.py new file mode 100644 index 0000000..6d5a1ac --- /dev/null +++ b/tests/integration/test_llm_provider_full.py @@ -0,0 +1,134 @@ +import os +import pytest +from unittest.mock import patch, MagicMock +from GramAddict.core.llm_provider import extract_json, log_openrouter_burn, query_llm, query_telepathic_llm + +def test_extract_json(): + # 1. Normal JSON + assert extract_json('{"a": 1}') == '{"a": 1}' + # 2. Markdown JSOn Block + assert extract_json('```json\n{"a": 1}\n```') == '{"a": 1}' + # 3. Trailing text + assert extract_json('{"a": 1}\nSome extra talk') == '{"a": 1}' + # 4. Incomplete/invalid json (Returns None if no brace match, or garbage if mismatched) + assert extract_json('{"a": 1') is None + assert extract_json("") is None + # 5. Nested braces with prefix + assert extract_json('Here is your response:\n{"a": {"b": 2}}') == '{"a": {"b": 2}}' + # 6. Think blocks + assert extract_json('thinking\n{"a":1}') == '{"a":1}' + +def test_log_openrouter_burn(): + with patch.dict(os.environ, {"OPENROUTER_API_KEY": "123"}), \ + patch('requests.get') as mock_get, \ + patch('GramAddict.core.llm_provider.logger.info') as mock_log: + + mock_resp = MagicMock() + mock_resp.status_code = 200 + mock_resp.json.return_value = {"data": {"usage": 0.5, "usage_daily": 0.1, "limit": 1.0}} + mock_get.return_value = mock_resp + + log_openrouter_burn() + mock_log.assert_called() + + # Exception inside log_openrouter_burn + with patch.dict(os.environ, {"OPENROUTER_API_KEY": "123"}), \ + patch('requests.get') as mock_get, \ + patch('GramAddict.core.llm_provider.logger.debug') as mock_debug: + mock_get.side_effect = Exception("Network Down") + + log_openrouter_burn() + mock_debug.assert_called() + + # No API Key + with patch.dict(os.environ, clear=True), patch('requests.get') as mock_get: + log_openrouter_burn() + mock_get.assert_not_called() + +def test_query_llm_success_openai(): + with patch('requests.post') as mock_post: + resp = MagicMock() + resp.status_code = 200 + resp.headers = {"x-openrouter-credits-spent": "0.001"} + resp.json.return_value = {"choices": [{"message": {"content": '{"test": 1}'}}]} + mock_post.return_value = resp + + res = query_llm( + url="http://api.com/v1/chat/completions", + model="gpt-4", + prompt="Hello", + format_json=True + ) + assert res.get("response") == '{"test": 1}' + +def test_query_llm_success_ollama(): + with patch('requests.post') as mock_post: + resp = MagicMock() + resp.status_code = 200 + resp.json.return_value = {"response": '{"test": 2}'} + mock_post.return_value = resp + + res = query_llm( + url="http://api.com", # no /v1/chat/completions + model="llama3", + prompt="Hello", + format_json=False + ) + assert res.get("response") == '{"test": 2}' + +def test_query_llm_failed_json_extraction(): + # If formatting demands JSON, but the response is pure text + with patch('requests.post') as mock_post: + resp = MagicMock() + resp.status_code = 200 + resp.json.return_value = {"response": 'Not a json'} + mock_post.return_value = resp + + # Test the branch that raises ValueError inside `query_llm` and defaults to returning None + res = query_llm( + url="http://api.com", + model="llama3", + prompt="Hello", + format_json=True + ) + assert res is None + +def test_query_llm_http_error_no_fallback(): + with patch('requests.post') as mock_post: + mock_post.side_effect = Exception("General Network Error") + + res = query_llm( + url="http://api.com", + model="llama3", + prompt="Hello" + ) + assert res is None + +def test_query_telepathic_llm(): + with patch('GramAddict.core.llm_provider.query_llm') as mock_llm: + mock_llm.return_value = {"response": "something"} + + res = query_telepathic_llm("llama3", "http://fake.api", "system", "user") + assert res == "something" + + # Edge Inference + with patch('GramAddict.core.config.Config') as MConfig, patch('GramAddict.core.llm_provider.query_llm') as mock_llm: + mock_llm.return_value = {"response": "edge_response"} + cfg = MConfig.return_value + cfg.args.ai_fallback_url = "http://edge.api" + cfg.args.ai_fallback_model = "edge_model" + + res = query_telepathic_llm("llama3", "http://fake.api", "sys", "usr", use_local_edge=True) + assert res == "edge_response" + + # Edge fallback config missing + with patch('GramAddict.core.config.Config', side_effect=Exception("No Config")): + with patch('GramAddict.core.llm_provider.query_llm') as mock_llm: + mock_llm.return_value = {"response": "fallback"} + res = query_telepathic_llm("m", "u", "s", "u", use_local_edge=True) + assert res == "fallback" + + # Nothing returned + with patch('GramAddict.core.llm_provider.query_llm') as mock_llm: + mock_llm.return_value = None + assert query_telepathic_llm("m", "u", "s", "u") == "{}" diff --git a/tests/integration/test_q_nav_graph.py b/tests/integration/test_q_nav_graph.py new file mode 100644 index 0000000..d66e505 --- /dev/null +++ b/tests/integration/test_q_nav_graph.py @@ -0,0 +1,70 @@ +import pytest +import logging +from unittest.mock import MagicMock, call, patch +from GramAddict.core.q_nav_graph import QNavGraph + +def test_qnavgraph_same_state_navigation_bug(): + """ + Test that reproducing the bug where `navigate_to` to the CURRENT state + triggers an unexpected `app_start()` restart due to `if not path:` treating `[]` as failure. + """ + mock_device = MagicMock() + mock_device.deviceV2 = MagicMock() + + graph = QNavGraph(mock_device) + graph.current_state = "ExploreFeed" + + graph.navigate_to("ExploreFeed", zero_engine=None) + mock_device.deviceV2.app_start.assert_not_called() + +def test_qnavgraph_semantic_recovery_any_state(): + """ + Ensures that semantic recovery (global nav bar mapping) triggers even if current_state is NOT 'UNKNOWN', + for example when transitioning from 'HomeFeed' to 'ReelsFeed' with an unknown graph path. + """ + mock_device = MagicMock() + mock_device.deviceV2.dump_hierarchy.return_value = "" + + graph = QNavGraph(mock_device) + graph.current_state = "HomeFeed" + + with patch.object(graph, '_execute_transition', return_value=True) as mock_exec: + # Patch the path finding: first it returns None (no known path), then it returns ["tap_reels_tab"] after recovery anchors it. + with patch.object(graph, '_find_path', side_effect=[None, ["tap_reels_tab"]]): + success = graph.navigate_to("ReelsFeed", zero_engine=None) + + # _execute_transition should have been called with "tap_reels_tab" for semantic recovery mapping + mock_exec.assert_has_calls([call("tap_reels_tab", None)]) + assert graph.current_state == "ReelsFeed" + +def test_qnavgraph_telepathic_tagging(caplog): + """ + Verifies that the transition logs correctly output the 'source' of the interaction + (e.g. '[Keyword]' or '[Agentic Fallback]') instead of hardcoding '[Vision Cortex]' on a score of 1.0. + """ + caplog.set_level(logging.INFO) + mock_device = MagicMock() + + graph = QNavGraph(mock_device) + + # 1. Test Keyword Fast Path (Score 1.0) + mock_device.deviceV2.dump_hierarchy.side_effect = ["", ""] + mock_telepathic = MagicMock() + mock_telepathic.find_best_node.return_value = { + "x": 100, "y": 100, "score": 1.0, "semantic": "test match", "source": "keyword", "skip": False + } + + with patch('GramAddict.core.telepathic_engine.TelepathicEngine.get_instance', return_value=mock_telepathic): + graph._execute_transition("tap_home_tab", None) + assert "QNavGraph executing transition 'tap_home_tab' via [Keyword]" in caplog.text + + # 2. Test Agentic Fallback (Score < 1.0) + caplog.clear() + mock_device.deviceV2.dump_hierarchy.side_effect = ["", ""] + mock_telepathic.find_best_node.return_value = { + "x": 100, "y": 100, "score": 0.85, "semantic": "test LLM", "source": "agentic_fallback", "skip": False + } + + with patch('GramAddict.core.telepathic_engine.TelepathicEngine.get_instance', return_value=mock_telepathic): + graph._execute_transition("tap_home_tab", None) + assert "QNavGraph executing transition 'tap_home_tab' via [Agentic Fallback]" in caplog.text diff --git a/tests/integration/test_qdrant_memory_full.py b/tests/integration/test_qdrant_memory_full.py new file mode 100644 index 0000000..8a4ac81 --- /dev/null +++ b/tests/integration/test_qdrant_memory_full.py @@ -0,0 +1,319 @@ +import os +import sys +import time +import pytest +from unittest.mock import patch, MagicMock + +# Inject mock qdrant_client + +from GramAddict.core.qdrant_memory import ( + QdrantBase, HeuristicMemoryDB, UIMemoryDB, CommentMemoryDB, + NavigationMemoryDB, PersonaMemoryDB, ContentMemoryDB, BannedPathsDB, ParasocialCRMDB, DMMemoryDB +) + +@pytest.fixture(autouse=True) +def mock_qdrant(): + with patch('GramAddict.core.qdrant_memory.QdrantClient') as mq: + yield mq + +def test_qdrant_base(mock_qdrant): + mock_client = MagicMock() + mock_qdrant.return_value = mock_client + + # Missing collection creation + mock_client.collection_exists.return_value = False + base = QdrantBase("test_collection", vector_size=4) + mock_client.create_collection.assert_called() + + # Dimension mismatch + dim_mock = MagicMock() + dim_mock.config.params.vectors.size = 2 + mock_client.get_collection.return_value = dim_mock + mock_client.collection_exists.return_value = True + base = QdrantBase("test_collection", vector_size=4) + # Should delete and recreate + mock_client.delete_collection.assert_called() + assert mock_client.create_collection.call_count == 2 + + # Upsert & Search + base.upsert_point("seed", {"a": 1}) + mock_client.upsert.assert_called() + base.search_points([0.0]*4) + mock_client.search.assert_called() + +def test_qdrant_base_embeddings(mock_qdrant): + base = QdrantBase("x", 4) + with patch('requests.post') as mock_post, patch('GramAddict.core.config.Config'): + # Ollama style + resp = MagicMock() + resp.status_code = 200 + resp.json.return_value = {"embedding": [0.1, 0.2]} + mock_post.return_value = resp + assert base._get_embedding("hi") == [0.1, 0.2] + + # OpenAI style + resp.json.return_value = {"data": [{"embedding": [0.3]}]} + assert base._get_embedding("hi") == [0.3] + + # Failure + mock_post.side_effect = Exception("failed") + assert base._get_embedding("hi") is None + +def test_heuristic_memory(mock_qdrant): + with patch('GramAddict.core.qdrant_memory.QdrantBase._get_embedding') as m_emb: + m_emb.return_value = [0.0] * 1536 + db = HeuristicMemoryDB() + + # learn heuristics + db.cache_heuristic("find_button", {"bounds": [0,0,10,10]}) + + # mock query_points + pt = MagicMock() + pt.payload = {"rule": "{'bounds': [0, 0, 10, 10]}", "rule_type": "regex"} + pt.score = 1.0 + mock_result = MagicMock() + mock_result.points = [pt] + db.client.query_points.return_value = mock_result + + res = db.fetch_heuristic("find_button") + assert res is not None + +def test_ui_memory_db(mock_qdrant): + with patch('GramAddict.core.qdrant_memory.QdrantBase._get_embedding') as m_emb: + m_emb.return_value = [0.0] * 1536 + db = UIMemoryDB() + db.store_memory("home", "", {"res": 1}) + + pt = MagicMock() + pt.payload = {"solution": {"res": 1}, "structural_signature": db._create_structural_signature(""), "confidence": 0.8} + pt.score = 1.0 + mock_result = MagicMock() + mock_result.points = [pt] + db.client.query_points.return_value = mock_result + + assert db.retrieve_memory("home", "") == {'res': 1} + + # confidence + db.client.query_points.return_value = mock_result + db.boost_confidence("home") + db.decay_confidence("home") + db.purge_stale_entries() + +def test_content_and_comments(mock_qdrant): + with patch('GramAddict.core.qdrant_memory.QdrantBase._get_embedding') as m_emb: + m_emb.return_value = [0.0] * 1536 + + # Comments + cdb = CommentMemoryDB() + cdb.store_comment("nice", "positive", "user") + cdb.client.upsert.assert_called() + + pt = MagicMock() + pt.payload = {"text": "nice"} + pt.score = 1.0 + mock_result = MagicMock() + mock_result.points = [pt] + cdb.client.query_points.return_value = mock_result + res = cdb.get_relevant_comments("post") + assert len(res) == 1 + + # Content + cndb = ContentMemoryDB() + cndb.store_evaluation("nice pic", "POSITIVE", "good vibe") + # pt payload + pt.payload = {"classification": "POSITIVE", "reason": "ok"} + pt.score = 1.0 + mock_result = MagicMock() + mock_result.points = [pt] + cndb.client.query_points.return_value = mock_result + assert cndb.get_cached_evaluation("nice pic") is not None + +def test_banned_paths_db(mock_qdrant): + mock_client = MagicMock() + mock_qdrant.return_value = mock_client + + # Mocking scroll to return some expired and some active + exp_pt = MagicMock() + exp_pt.id = "exp" + exp_pt.payload = {"banned_at": 100, "goal_hash": "a", "element_id": "e1"} # VERY OLD + + act_pt = MagicMock() + act_pt.id = "act" + act_pt.payload = {"banned_at": time.time(), "goal_hash": "b", "element_id": "e2"} + + mock_client.scroll.return_value = ([exp_pt, act_pt], None) + + db = BannedPathsDB() + + # Should have run clean up for exp_pt, and loaded act_pt + mock_client.delete.assert_called() + assert len(db._banned) == 1 + + # ban new + db.ban("My Goal", "ui_123", "Not working") + mock_client.upsert.assert_called() + + # check + assert db.is_banned("My Goal", "ui_123") == True + +def test_navigation_memory_db(mock_qdrant): + db = NavigationMemoryDB() + with patch('GramAddict.core.qdrant_memory.uuid.uuid4', return_value="1234"): + db.store_transition("Feed", "click_home", "Home") + db.client.upsert.assert_called() + + pt = MagicMock() + pt.payload = {"from": "Feed", "action": "click_home", "to": "Home"} + db.client.scroll.return_value = ([pt], None) + res = db.get_all_transitions() + assert res.get("Feed") == {"transitions": {"click_home": "Home"}} + +def test_persona_memory_db(mock_qdrant): + with patch('GramAddict.core.qdrant_memory.QdrantBase._get_embedding') as m_emb: + m_emb.return_value = [0.0] * 1536 + db = PersonaMemoryDB() + + db.store_persona_insight("likes", "Loves tech") + pt = MagicMock() + pt.payload = {"category": "likes", "insight": "Loves tech"} + db.client.scroll.return_value = ([pt], None) + assert "Loves tech" in db.get_persona_context("likes") + +def test_crm_db(mock_qdrant): + with patch('GramAddict.core.qdrant_memory.ParasocialCRMDB.is_connected', new_callable=MagicMock, return_value=True), patch('GramAddict.core.qdrant_memory.QdrantBase._get_embedding') as m_emb: + m_emb.return_value = [0.0] * 1536 + db = ParasocialCRMDB() + pt = MagicMock() + pt.payload = {"stage": 1, "intent_history": ["LIKE"], "last_interaction": 100} + # ParasocialCRMDB uses scroll + db.client.scroll.return_value = ([pt], None) + + res = db.get_relationship_stage("user") + assert res["stage"] == 1 + + db.log_interaction("user", "COMMENT") + db.client.upsert.assert_called() + + db.log_generated_comment("user", "hi") + db.log_profile_context("user", "Tech dev") + + # Simulate DB state updated + pt.payload["bio"] = "Tech dev" + assert "Tech dev" in db.get_conversation_context("user") + +def test_dm_history_db(mock_qdrant): + with patch('GramAddict.core.qdrant_memory.QdrantBase._get_embedding') as m_emb: + m_emb.return_value = [0.0] * 1536 + db = DMMemoryDB() + db.log_sent_dm("user", "hi", "bio", []) + db.client.upsert.assert_called() + + pt = MagicMock() + pt.payload = {"target_username": "user", "message": "hi", "score": 0.9} + + mock_result = MagicMock() + mock_result.points = [pt] + db.client.query_points.return_value = mock_result + db.client.scroll.return_value = ([pt], None) + + pending = db.get_pending_dms() + assert len(pending) == 1 + + db.update_dm_score("123", 1.0) + db.client.set_payload.assert_called() + + best = db.get_best_performing_dms() + assert len(best) == 1 + +def test_unhappy_paths(mock_qdrant): + mock_client = MagicMock() + mock_qdrant.return_value = mock_client + with patch('GramAddict.core.qdrant_memory.QdrantBase._get_embedding') as m_emb: + m_emb.return_value = [0.0] * 1536 + + # Test 1: Exception on query_points + db = UIMemoryDB() + db.client.query_points.side_effect = Exception("failed") + assert db.retrieve_memory("home", "") is None + + # Test 2: Exception on upsert + db.client.upsert.side_effect = Exception("failed") + db.store_memory("home", "", {"res": 1}) # shouldn't crash + + # _adjust_confidence coverage + db.client.retrieve.return_value = [] + db.boost_confidence("home") # handles empty retrieve + + pt = MagicMock() + pt.payload = {"confidence": 0.5} + db.client.retrieve.return_value = [pt] + db.decay_confidence("home", amount=1.0) # falls below 0.1, calls delete + db.client.delete.assert_called() + + # purge stale entries + stale_pt = MagicMock() + stale_pt.payload = {"confidence": 0.4, "stored_at": 100} + db.client.scroll.return_value = ([stale_pt], None) + db.purge_stale_entries() + db.client.delete.assert_called() + + # fetch heuristic fail + db = HeuristicMemoryDB() + db.client.query_points.side_effect = Exception("failed") + assert db.fetch_heuristic("button") is None + + cndb = ContentMemoryDB() + cndb.client.query_points.side_effect = Exception("failed") + assert cndb.get_cached_evaluation("pic") is None + + # get_similar_examples + db.client.query_points.side_effect = None + pt.payload = {"description": "hello", "classification": "A", "reason": "B"} + mock_result = MagicMock() + mock_result.points = [pt] + cndb.client.query_points.return_value = mock_result + res = cndb.get_similar_examples("pic") + assert len(res) == 1 + assert res[0]["classification"] == "A" + +def test_disconnected_state(mock_qdrant): + with patch('GramAddict.core.qdrant_memory.QdrantBase.is_connected', new_callable=MagicMock, return_value=False), patch('GramAddict.core.qdrant_memory.QdrantBase._get_embedding') as m_emb: + m_emb.return_value = None + db = UIMemoryDB() + assert db.retrieve_memory("home", "") is None + db.store_memory("home", "", {}) + db._adjust_confidence("home", 0.1) + + cdb = CommentMemoryDB() + assert cdb.get_relevant_comments("post") == [] + cdb.store_comment("p", "a", "u") + + crm = ParasocialCRMDB() + assert crm.get_relationship_stage("user")["stage"] == 0 + crm.log_profile_context("u", "b") + crm.log_interaction("u", "intent") + crm.log_generated_comment("u", "t") + + dm = DMMemoryDB() + dm.update_dm_score("123", 1.0) + assert dm.get_pending_dms() == [] + assert dm.get_best_performing_dms() == [] + dm.log_sent_dm("a", "b", "c", []) + + cndb = ContentMemoryDB() + assert cndb.get_similar_examples("hello") == [] + assert cndb.get_cached_evaluation("hi") == None + cndb.store_evaluation("a", "b", "c") + + ndb = NavigationMemoryDB() + assert ndb.get_all_transitions() == {} + ndb.store_transition("a", "b", "c") + + pdb = PersonaMemoryDB() + assert pdb.get_persona_context("C") == "" + pdb.store_persona_insight("a", "b") + + hdb = HeuristicMemoryDB() + assert hdb.fetch_heuristic("H") is None + hdb.cache_heuristic("a", {}) + diff --git a/tests/integration/test_resonance_engine.py b/tests/integration/test_resonance_engine.py new file mode 100644 index 0000000..795fb1c --- /dev/null +++ b/tests/integration/test_resonance_engine.py @@ -0,0 +1,199 @@ +import pytest +from unittest.mock import patch, MagicMock +from GramAddict.core.resonance_engine import ResonanceEngine + +@pytest.fixture +def engine(): + # Patch the databases at the source to prevent any real Qdrant connection + with patch('GramAddict.core.resonance_engine.ContentMemoryDB') as mock_cm_cls, \ + patch('GramAddict.core.resonance_engine.PersonaMemoryDB'): + + # Create a single consistent mock instance for ContentMemory + mock_cm = MagicMock() + mock_cm_cls.return_value = mock_cm + + # KEY: Ensure cache lookups return None to avoid fake hits with MagicMocks + mock_cm.get_cached_evaluation.return_value = None + + # Mock embedding return to ensure truthy checks pass + mock_cm._get_embedding.return_value = [0.1] * 1536 + + # Initialize + eng = ResonanceEngine(my_username="test_user", persona_interests=["fitness", "travel"]) + + # MANUALLY FORCE VALID STATE + eng._persona_vector = [0.1] * 1536 + eng.content_memory = mock_cm # Re-enforce the mock + + return eng + +def test_resonance_calculation_happy_path(engine): + """Verifies that resonance is calculated correctly for matching content.""" + post_data = { + "username": "fitness_junkie", + "description": "Amazing morning workout session #fitness #gym", + "caption": "No pain no gain" + } + + # 1. Provide Real Matching Vectors (exactly the same = 1.0 similarity) + # The real _persona_vector is [0.1]*1536 (from fixture). + # Returning the same vector for the content. + engine.content_memory._get_embedding.return_value = [0.1] * 1536 + + # 2. Real Math Logic + score = engine.calculate_resonance(post_data) + # Cosine Similarity 1.0 -> Normalization (1.0 - 0.15)/0.30 -> capped to 1.000 + assert score == 1.0 + assert engine.judge_interaction(score) is True + +def test_resonance_calculation_low_match(engine): + """Verifies low score for non-matching content.""" + post_data = { + "username": "politics_daily", + "description": "New tax law discussed in parliament", + "caption": "Breaking news" + } + + # Provide Orthogonal/Opposite Vectors (-0.1 to differ from 0.1) + engine.content_memory._get_embedding.return_value = [-0.1] * 1536 + + score = engine.calculate_resonance(post_data) + # Similarity will be low/negative -> Final score 0.0 + assert score == 0.0 + assert engine.judge_interaction(score) is False + +def test_resonance_no_content(engine): + """Empty content should return neutral score (0.5).""" + post_data = {"username": "ghost", "description": "", "caption": ""} + score = engine.calculate_resonance(post_data) + assert score == 0.5 + +def test_resonance_caching(engine): + """Verify that ContentMemoryDB cache is checked first.""" + post_data = { + "username": "test", + "description": "Some recycled content", + "caption": "Again" + } + + # Reset mock to verify it's not called + engine.content_memory._get_embedding.reset_mock() + engine.content_memory._get_embedding.return_value = [0.1] * 1536 + + # Mock cache hit + engine.content_memory.get_cached_evaluation.return_value = {"classification": "high"} + + score = engine.calculate_resonance(post_data) + assert score == 0.85 # 'high' classification from cache + + # Should not have called embedding for the post + engine.content_memory._get_embedding.assert_not_called() + +def test_extract_and_learn_comments_llm_kwargs(engine): + """Verifies that query_llm is called with correct kwargs to prevent 'multiple values for argument' exception.""" + configs = MagicMock() + configs.args = MagicMock() + configs.args.ai_condenser_model = "test-model" + configs.args.ai_condenser_url = "http://test-url" + + # Mock XML dump containing some fake comments + xml_content = ''' + + + + + ''' + + with patch('builtins.open', return_value=MagicMock(__enter__=MagicMock(return_value=MagicMock(read=MagicMock(return_value=xml_content))))), \ + patch('os.path.exists', return_value=True), \ + patch('GramAddict.core.resonance_engine.query_llm', autospec=True) as mock_query, \ + patch('GramAddict.core.resonance_engine.CommentMemoryDB') as mock_db: + + mock_query.return_value = {"response": '["Omg this is such a cool post! I love the lighting."]'} + + # This should naturally pass if kwargs are valid, or raise TypeError if it's the bug + configs.args.ai_learn_comments = True + configs.args.ai_vibe = "friendly" + configs.args.ai_blacklist_topics = "nsfw" + + engine.extract_and_learn_comments( + xml_hierarchy=xml_content, + configs=configs, + author="test_author" + ) + + # We can also assert that query_llm was indeed called correctly + mock_query.assert_called_once() + args, kwargs = mock_query.call_args + + # The prompt is the first positional argue + # We want to ensure that "url" and "model" are correctly mapped, and no duplicate positional argument is provided + # that overlaps with "url". If prompt is pos 0, 'url' parameter from query_llm is also pos 0. + # This assertion will fail if Python raises the TypeError first. + +def test_resonance_math_normalization(engine): + """Verifies that the normalization math for text-embedding-3-small allows natural matches to score HIGH.""" + # text-embedding-3-small real matches are typically around 0.45-0.55 raw cosine. + # We want a raw cosine similarity of 0.45 to yield a normalized score >= 0.85 (High resonance) + # The current math returns around 0.25 (Low relevance), which effectively blocks all Autonomous likes/comments. + + post_data = { + "username": "perfect_match", + "description": "This is a mathematically perfect match for the persona", + "caption": "" + } + + # THE MATHEMATICAL TRICK: + # To get raw cosine 0.45 with a persona vector of [0.1]*1536: + # We need a content vector such that sum(a*b)/(norm(a)*norm(b)) = 0.45 + + persona_vec = [0.1] * 1536 + # Create a vector that is partially aligned + content_vec = [0.1] * 691 + [0.0] * 845 # 691/1536 is approx 0.45 + + engine._persona_vector = persona_vec + engine.content_memory._get_embedding.return_value = content_vec + + score = engine.calculate_resonance(post_data) + # (0.45 - 0.15) / 0.30 = 1.0 (Previously it was failing) + assert score >= 0.85 + +def test_extract_and_learn_comments_lenient_prompt(): + """ + Test that the Condenser prompt is lenient enough to not return empty lists constantly. + We verify the prompt contains the lenient phrasing instead of 'perfectly match'. + """ + engine = ResonanceEngine(my_username="test_bot") + + # Mock configs for comment learning + configs = MagicMock() + configs.args.ai_learn_comments = True + configs.args.ai_vibe = "friendly, authentic" + configs.args.ai_blacklist_topics = "crypto, spam" + + # Minimal XML + xml = ''' + + + + + ''' + + with patch('GramAddict.core.resonance_engine.query_llm') as mock_llm: + mock_llm.return_value = {"response": "[\"This lighting trick is insane!\"]"} + + # Act + with patch('GramAddict.core.resonance_engine.CommentMemoryDB') as MockDB: + engine.extract_and_learn_comments(xml_hierarchy=xml, configs=configs) + + # Assert + assert mock_llm.call_count == 1 + call_kwargs = mock_llm.call_args.kwargs + prompt = call_kwargs.get("prompt", "") + + # Ensure we are using the lenient mapping theorem + assert "generally match this vibe" in prompt + assert "perfectly match the vibe" not in prompt + + # Verify the parsed comments were still passed + assert "This lighting trick is insane!" in prompt diff --git a/tests/integration/test_scenarios_fsd.py b/tests/integration/test_scenarios_fsd.py new file mode 100644 index 0000000..84d297a --- /dev/null +++ b/tests/integration/test_scenarios_fsd.py @@ -0,0 +1,299 @@ +import sys +from unittest.mock import MagicMock + +# Force mock qdrant_client before importing any core modules that depend on it + +import pytest +import os +from unittest.mock import patch +from GramAddict.core.bot_flow import _run_zero_latency_feed_loop + +FIX_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "fixtures") + +class ArgsMock: + def __init__(self): + self.username = ["test_bot"] + self.interact_percentage = 100 + self.likes_percentage = 100 + self.total_likes_limit = 100 + self.total_follows_limit = 100 + self.total_unfollows_limit = 100 + self.total_comments_limit = 100 + self.total_pm_limit = 100 + self.total_watches_limit = 100 + self.total_successful_interactions_limit = 100 + self.total_interactions_limit = 100 + self.total_scraped_limit = 100 + self.total_crashes_limit = 5 + # Session state attributes expect these to exist + self.current_likes_limit = 100 + self.current_follow_limit = 100 + self.current_unfollow_limit = 100 + self.current_comments_limit = 100 + self.current_pm_limit = 100 + self.current_watch_limit = 100 + self.current_success_limit = 100 + self.current_total_limit = 100 + self.current_scraped_limit = 100 + self.current_crashes_limit = 5 + self.end_if_likes_limit_reached = False + self.end_if_follows_limit_reached = False + self.end_if_watches_limit_reached = False + self.end_if_comments_limit_reached = False + self.end_if_pm_limit_reached = False + +class ConfigMock: + def __init__(self): + self.can_like = True + self.can_comment = False + self.can_follow = False + self.can_watch_stories = False + self.interaction_limit_reached = lambda: False + self.is_last_post = lambda x: False + self.args = ArgsMock() + + +@pytest.fixture +def fsd_fixtures(): + def _load(name): + with open(os.path.join(FIX_DIR, name), "r") as f: + return f.read() + return { + "organic": _load("organic_post.xml"), + "ad": _load("sponsored_reel.xml"), + "modal": _load("survey_modal.xml") + } + +def test_full_mission_autopilot_sequence(fsd_fixtures): + """ + MASTER SCENARIO: + 1. Organic Post -> Action: LIKE + 2. Ad -> Action: SKIP (SCROLL) + 3. Survey Modal -> Action: DISMISS (TELEPATHIC) + 4. Organic Post -> Action: LIKE + 5. End Session (Boredom) + """ + device = MagicMock() + device.get_info.return_value = {"displayWidth": 1080, "displayHeight": 2400} + configs = ConfigMock() + + # Sequence of UI states + ui_sequence = [ + fsd_fixtures["organic"], # 0. First Organic Post + fsd_fixtures["ad"], # 1. Ad (Detected via resource-id) + fsd_fixtures["modal"], # 2. Modal (Miss 1) + fsd_fixtures["modal"], # 3. Modal (Miss 2 -> Telepathic Recovery) + fsd_fixtures["organic"], # 4. Second Organic Post + fsd_fixtures["organic"] # Buffer + ] + state = {"index": 0} + + def get_ui(): + idx = min(state["index"], len(ui_sequence) - 1) + return ui_sequence[idx] + + def advance_state(*args, **kwargs): + state["index"] += 1 + print(f"DEBUG: State advanced to {state['index']}") + + device.deviceV2.dump_hierarchy.side_effect = get_ui + device.deviceV2.click.side_effect = advance_state + + # Trackers + class CRMTracker: + def __init__(self): self.interacted_users = [] + def log_interaction(self, username, intent): + print(f"DEBUG: CRM log_interaction called for @{username} with {intent}") + self.interacted_users.append(username) + def log_profile_context(self, *args, **kwargs): pass + + class DarwinTracker: + def __init__(self): self.called = False + def execute_micro_wobble(self, *args, **kwargs): pass + def execute_proof_of_resonance(self, *args, **kwargs): self.called = True + def synthesize_interaction_profile(self, *args, **kwargs): self.called = True + def evaluate_session_end(self, *args, **kwargs): pass + + crm = CRMTracker() + darwin = DarwinTracker() + swarm = MagicMock() + resonance = MagicMock() + + # Mock Resonance to always like organic posts + resonance.calculate_resonance.return_value = 0.9 + + # --- DETOX: Use REAL engines, mock only the BOUNDARY (LLM/DB) --- + from GramAddict.core.telepathic_engine import TelepathicEngine + from GramAddict.core.resonance_engine import ResonanceEngine + from GramAddict.core.swarm_protocol import SwarmProtocol + from GramAddict.core.session_state import SessionState + import hashlib + import builtins + + # Capture original open BEFORE any patching to avoid recursion + original_open = builtins.open + + def deterministic_embedding(text): + """Generates a stable, unique 1536-dim vector for any string.""" + # Use MD5 to get 16 bytes, then repeat to fill or just use first 16 floats + h = hashlib.md5(text.encode()).digest() + base = [float(b)/255.0 for b in h] + # Pad to 1536 with zeros or repeat + return (base * (1536 // 16 + 1))[:1536] + + # We mock only the external API/Boundary calls inside the engines + with patch('GramAddict.core.qdrant_memory.QdrantClient') as MockClient, \ + patch('GramAddict.core.qdrant_memory.QdrantBase._get_embedding', side_effect=deterministic_embedding), \ + patch('GramAddict.core.telepathic_engine.query_telepathic_llm') as mock_vlm_api, \ + patch('GramAddict.core.bot_flow.sleep'), \ + patch('GramAddict.core.bot_flow._humanized_scroll', side_effect=advance_state), \ + patch('builtins.open', new_callable=MagicMock) as mock_file_open, \ + patch('random.random', return_value=0.99): # Pass interaction gates and bypass Resonance Skip + + # Setup fake file reading for VLM screenshot + mock_file_open.return_value.__enter__.return_value.read.return_value = b"fake_screenshot_bytes" + # We need to selectively mock open for 'vlm_context.jpg' and allow real open for XML fixtures + def side_effect_open(path, *args, **kwargs): + if "vlm_context.jpg" in str(path): + return mock_file_open.return_value + return original_open(path, *args, **kwargs) + mock_file_open.side_effect = side_effect_open + + # Harden Qdrant Config Mock to prevent dimension warnings + mock_client = MockClient.return_value + mock_client.collection_exists.return_value = False + + # Force the REAL TelepathicEngine instead of conftest's MockTelepathicEngine + telepathic = TelepathicEngine() + + # CLEAR MEMORY TO ENSURE VLM TRIGGER + if os.path.exists("telepathic_memory.json"): + os.remove("telepathic_memory.json") + + with patch('GramAddict.core.telepathic_engine.TelepathicEngine.get_instance', return_value=telepathic): + resonance = ResonanceEngine(my_username="test_bot", persona_interests=["travel", "nature"]) + # Mock the specific method to always like organic posts, bypassing the deterministic embedding math + resonance.calculate_resonance = MagicMock(return_value=0.9) + swarm = SwarmProtocol(username="test_bot") + + cognitive_stack = { + "active_inference": MagicMock(), + "dopamine": MagicMock(), + "growth_brain": MagicMock(), + "resonance": resonance, + "crm": crm, + "swarm": swarm, + "darwin": darwin, + "telepathic": telepathic + } + + # Setup AI recovery (boundary mock result) + mock_vlm_api.return_value = '{"index": 2, "reason": "Dismiss Button"}' + + # Setup Dopamine to run exactly long enough + cognitive_stack["dopamine"].is_app_session_over.side_effect = [False] * 12 + [True] + cognitive_stack["dopamine"].wants_to_change_feed.return_value = False + cognitive_stack["dopamine"].wants_to_doomscroll.return_value = False + + # Run interaction loop - we patch swarm's emit_pheromone to verify it was called + with patch.object(swarm, 'emit_pheromone'): + session_state = SessionState(configs) + _run_zero_latency_feed_loop(device, MagicMock(), MagicMock(), configs, session_state, "HomeFeed", cognitive_stack) + + # VERIFICATION + + # 1. Sequence Progression + assert state["index"] >= 4, f"Bot sequence failed to progress. Final index: {state['index']}" + + # 2. Interaction Accuracy (CRM) + # Real ResonanceEngine should have evaluated 'hoeltlfinanzgmbh' as high resonance + assert len(crm.interacted_users) >= 1, "CRM recorded ZERO interactions!" + assert "fiona.dawson" in crm.interacted_users or "hoeltlfinanzgmbh" in crm.interacted_users + + # 3. Anomaly Handling + # Real TelepathicEngine should have called the Vision LLM (mock_vlm_api) + assert mock_vlm_api.called, "Anomaly recovery via REAL Vision Cortex was NEVER triggered!" + + # 4. Resonance Proof + assert darwin.called, "Darwin Engine was NEVER called for resonance proof!" + assert swarm.emit_pheromone.called, "Swarm Protocol NEVER emitted success pheromones!" + + print("\n🏆 TRUE INTEGRATION SCENARIO PASSED!") + print(f"Interacted with: {crm.interacted_users}") +def test_feed_loop_chaos_mode(fsd_fixtures): + """ + CHAOS MODE SCENARIO: + Simulate unpredictable UI behavior, random context loss, and unhandled exceptions + to ensure the zero-latency feed loop handles errors gracefully without crashing. + """ + device = MagicMock() + device.get_info.return_value = {"displayWidth": 1080, "displayHeight": 2400} + + class ConfigMock: + def __init__(self): + self.args = MagicMock() + self.args.interact_percentage = 100 + self.args.likes_percentage = 100 + self.args.follow_percentage = 0 + self.args.comment_percentage = 0 + self.args.repost_percentage = 0 + + configs = ConfigMock() + + # Sequence with invalid XML, completely empty hierarchy, then normal + ui_sequence = [ + "INVALID XML {{", + "", + fsd_fixtures["organic"] + ] + state = {"index": 0} + + def get_ui(): + idx = min(state["index"], len(ui_sequence) - 1) + return ui_sequence[idx] + + def advance_state(*args, **kwargs): + state["index"] += 1 + + device.deviceV2.dump_hierarchy.side_effect = get_ui + device.deviceV2.click.side_effect = advance_state + + from GramAddict.core.sensors.honeypot_radome import HoneypotRadome + + with patch('GramAddict.core.bot_flow.sleep'), \ + patch('GramAddict.core.bot_flow._humanized_scroll', side_effect=advance_state): + + telepathic = MagicMock() + # Have telepathic throw an error to simulate chaos/random failure + telepathic._extract_semantic_nodes.side_effect = Exception("CHAOS INJECTION") + + cognitive_stack = { + "active_inference": MagicMock(), + "dopamine": MagicMock(), + "growth_brain": MagicMock(), + "resonance": MagicMock(), + "crm": MagicMock(), + "swarm": MagicMock(), + "darwin": MagicMock(), + "radome": HoneypotRadome(1080, 2400), + "telepathic": telepathic, + "nav_graph": MagicMock(), + "zero_engine": MagicMock() + } + cognitive_stack["resonance"].calculate_resonance.return_value = 0.9 + + cognitive_stack["dopamine"].is_app_session_over.side_effect = [False, False, False, True] + cognitive_stack["dopamine"].wants_to_change_feed.return_value = False + cognitive_stack["dopamine"].wants_to_doomscroll.return_value = False + + session_state = MagicMock() + session_state.check_limit.side_effect = lambda limit_type: (False, False, False, False) if getattr(limit_type, "name", "") == "ALL" else False + + from GramAddict.core.bot_flow import _run_zero_latency_feed_loop + + # The loop should not crash despite exceptions (e.g. invalid XML or CHAOS exception from telepathic) + # Instead, it should catch exceptions and use _humanized_scroll or abort safely + _run_zero_latency_feed_loop(device, cognitive_stack["zero_engine"], cognitive_stack["nav_graph"], configs, session_state, "HomeFeed", cognitive_stack) + + # Should have advanced through the states via fallback scroll mechanism + assert state["index"] >= 1 diff --git a/tests/integration/test_swarm_protocol.py b/tests/integration/test_swarm_protocol.py new file mode 100644 index 0000000..8ce1b8a --- /dev/null +++ b/tests/integration/test_swarm_protocol.py @@ -0,0 +1,54 @@ +import pytest +from unittest.mock import MagicMock, patch, PropertyMock +from GramAddict.core.swarm_protocol import SwarmProtocol + +@pytest.fixture +def swarm(): + with patch('GramAddict.core.qdrant_memory.QdrantClient'): + return SwarmProtocol(username="test_bot") + +def test_emit_pheromone(swarm): + """Verify that emitting a pheromone calls Qdrant upsert with correct payload.""" + with patch("GramAddict.core.qdrant_memory.QdrantBase.is_connected", new_callable=PropertyMock, return_value=True): + path_hash = "some_ui_path_hash" + outcome = "success" + + swarm.emit_pheromone(path_hash, outcome) + + # Check if upsert was called with the expected payload + swarm.client.upsert.assert_called_once() + args, kwargs = swarm.client.upsert.call_args + points = kwargs.get('points') + assert points[0].payload['path_hash'] == path_hash + assert points[0].payload['outcome'] == outcome + assert points[0].payload['username'] == "test_bot" + +def test_query_consensus_hit(swarm): + """Verify consensus query returns the outcome from Qdrant scroll.""" + with patch("GramAddict.core.qdrant_memory.QdrantBase.is_connected", new_callable=PropertyMock, return_value=True): + path_hash = "known_path" + + # Mock scroll result + mock_point = MagicMock() + mock_point.payload = {"outcome": "banned"} + swarm.client.scroll.return_value = ([mock_point], None) + + result = swarm.query_consensus(path_hash) + assert result == "banned" + swarm.client.scroll.assert_called_once() + +def test_query_consensus_miss(swarm): + """Verify None is returned when no pheromones found.""" + with patch("GramAddict.core.qdrant_memory.QdrantBase.is_connected", new_callable=PropertyMock, return_value=True): + swarm.client.scroll.return_value = ([], None) + + result = swarm.query_consensus("unknown_path") + assert result is None + +def test_offline_mode(swarm): + """Protocol should not crash if Qdrant is disconnected.""" + with patch("GramAddict.core.qdrant_memory.QdrantBase.is_connected", new_callable=PropertyMock, return_value=False): + swarm.emit_pheromone("any", "thing") + swarm.client.upsert.assert_not_called() + + assert swarm.query_consensus("any") is None diff --git a/tests/integration/test_telepathic_edge_cases.py b/tests/integration/test_telepathic_edge_cases.py new file mode 100644 index 0000000..56841e7 --- /dev/null +++ b/tests/integration/test_telepathic_edge_cases.py @@ -0,0 +1,167 @@ +import pytest +import math +import os +import tempfile +import json +from unittest.mock import patch, MagicMock + +import sys +# Force mock qdrant_client before importing any core modules that depend on it + +from GramAddict.core.telepathic_engine import TelepathicEngine + +class TestTelepathicEngineEdgeCases: + + @pytest.fixture(autouse=True) + def setup_engine(self): + self.engine = TelepathicEngine() + + def test_cosine_similarity_edge_cases(self): + # 0 vectors + assert self.engine._cosine_similarity([0,0,0], [0,0,0]) == 0.0 + assert self.engine._cosine_similarity([1,2,3], [0,0,0]) == 0.0 + + # Mismatched sizes + assert self.engine._cosine_similarity([1,2], [1,2,3]) == 0.0 + + # Empty lists + assert self.engine._cosine_similarity([], []) == 0.0 + + # Valid vectors + assert self.engine._cosine_similarity([1,0], [1,0]) == 1.0 + assert self.engine._cosine_similarity([1,0], [0,1]) == 0.0 + assert self.engine._cosine_similarity([1,1], [1,1]) > 0.99 + + def test_json_io_edge_cases(self): + # Try to load non-existent + with tempfile.TemporaryDirectory() as tmpdir: + file_path = os.path.join(tmpdir, "missing.json") + assert self.engine._load_json(file_path) == {} + + # Save dict + self.engine._save_json(file_path, {"test": "ok"}) + assert self.engine._load_json(file_path) == {"test": "ok"} + + # Corrupted json + with open(file_path, "w") as f: + f.write("corrupted { string") + + assert self.engine._load_json(file_path) == {} + + def test_structural_sanity_check_edge_cases(self): + # Good node + good_node = {"y": 500, "area": 1000} + assert self.engine._structural_sanity_check(good_node, "tap button") == True + + # Status bar zone (y < 4% of 2400 = 96) + status_bar_node = {"y": 50, "area": 1000} + assert self.engine._structural_sanity_check(status_bar_node, "tap button") == False + + # Massive container without media intent + massive_node = {"y": 500, "area": 600000} # > MAX_CONTAINER_AREA (500000) + assert self.engine._structural_sanity_check(massive_node, "tap button") == False + + # Massive container WITH media intent (allowed) + assert self.engine._structural_sanity_check(massive_node, "watch video post") == True + + # 0 size + invisible_node = {"y": 500, "area": 0} + assert self.engine._structural_sanity_check(invisible_node, "tap button") == False + + # Negative bounds/y, shouldn't crash, returns False + neg_node = {"y": -10, "area": 1000} + assert self.engine._structural_sanity_check(neg_node, "tap button") == False + + def test_is_instagram_context_edge_cases(self): + # Set app ID + self.engine._cached_app_id = "com.instagram.android" + + # No nodes + assert self.engine._is_instagram_context([]) == False + + # Nodes from wrong app + wrong_app_nodes = [{"resource_id": "com.youtube.android:id/btn"}] + assert self.engine._is_instagram_context(wrong_app_nodes) == False + + # Nodes from right app + right_app_nodes = [{"resource_id": "com.instagram.android:id/btn"}] + assert self.engine._is_instagram_context(right_app_nodes) == True + + # Missing resource_id + missing_id_nodes = [{"y": 10}] + assert self.engine._is_instagram_context(missing_id_nodes) == False + + def test_keyword_match_score_edge_cases(self): + # Empty intent (all filler words) + assert self.engine._keyword_match_score("tap the on a", [{"semantic_string": "button"}]) == None + + # Empty nodes + assert self.engine._keyword_match_score("home", []) == None + + # Valid nodes + Alias testing + nodes = [ + {"semantic_string": "main view section", "x": 10, "y": 10, "area": 100}, + {"semantic_string": "search bar", "x": 20, "y": 20, "area": 200} + ] + + # Alias: "home" expands to "main" + # The word 'home' is checked against 'main view section' and gets a hit + res = self.engine._keyword_match_score("tap home tab", nodes) + assert res is not None + assert res["semantic"] == "main view section" + assert res["score"] == 0.95 + + # No matches + assert self.engine._keyword_match_score("tap settings menu xyz", nodes) == None + + # Like check (already liked) + liked_nodes = [ + {"semantic_string": "heart button", "original_attribs": {"desc": "Liked by john"}} + ] + res_like = self.engine._keyword_match_score("tap like button", liked_nodes) + assert res_like["skip"] == True + assert res_like["semantic"] == "already_liked" + + def test_click_tracking_and_learning_edge_cases(self): + from GramAddict.core.telepathic_engine import TelepathicEngine as TE + + # Clear tracker + TE._last_click_context = None + + # confirming with no tracked click + self.engine.confirm_click("test") # Should not crash + + # tracking + node = {"semantic_string": "my button", "x": 10, "y": 20} + self.engine._track_click("tap my button", node) + + assert TE._last_click_context is not None + + # Use a temporary dict for memory so we don't write to disk during test + self.engine._memory = {} + with patch.object(self.engine, '_save_json'): + self.engine.confirm_click() + + # Check if stored + assert "tap my button" in self.engine._memory + assert "my button" in self.engine._memory["tap my button"] + + # Confirming AGAIN should not duplicate + self.engine._track_click("tap my button", node) + self.engine.confirm_click() + assert len(self.engine._memory["tap my button"]) == 1 + + # Rejecting + self.engine._track_click("tap my button", node) + self.engine.reject_click() + + # Should be removed from positive memory and added to blacklist + assert "my button" not in self.engine._memory.get("tap my button", []) + assert "my button" in self.engine._blacklist.get("tap my button", []) + + # Confirming a blacklisted item should rehabilitate it + self.engine._track_click("tap my button", node) + self.engine.confirm_click() + assert "my button" in self.engine._memory.get("tap my button", []) + assert "my button" not in self.engine._blacklist.get("tap my button", []) + diff --git a/tests/integration/test_telepathic_engine_extraction.py b/tests/integration/test_telepathic_engine_extraction.py new file mode 100644 index 0000000..16dba03 --- /dev/null +++ b/tests/integration/test_telepathic_engine_extraction.py @@ -0,0 +1,373 @@ +""" +Test Suite: Real XML Fixture Validation +======================================== +These tests use REAL UIAutomator XML dumps captured from a live Instagram +session on the device. No hand-crafted node arrays — the full XML goes +through _extract_semantic_nodes() exactly like in production. + +This catches bugs that mock-based tests miss: +- Parser skipping nodes due to missing attribs +- Parser including non-interactive system UI elements +- Safety guard false positives on real Instagram layouts +- Ad detection on real ad XML structures +""" +import pytest +import re +import os +from unittest.mock import MagicMock, patch +import json +from GramAddict.core.telepathic_engine import TelepathicEngine + +FIXTURE_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "fixtures") + + +def load_fixture(name: str) -> str: + """Load a real XML capture from tests/fixtures/""" + path = os.path.join(FIXTURE_DIR, name) + with open(path, "r") as f: + return f.read() + + +class TestNodeExtraction: + """ + Tests that _extract_semantic_nodes correctly parses REAL Instagram XML. + Uses captured XML dumps from the actual device. + """ + + def test_home_feed_extracts_like_button(self): + """ + In a real Home Feed dump, the parser MUST find the Like button node + with resource-id 'row_feed_button_like'. + """ + engine = TelepathicEngine() + xml = load_fixture("home_feed_with_ad.xml") + nodes = engine._extract_semantic_nodes(xml) + + like_nodes = [n for n in nodes if "row feed button like" in n["semantic_string"]] + # The real dump has an organic post AND an ad post, both with like buttons + assert len(like_nodes) > 0, ( + "Like buttons must be extracted despite clickable=false, because our " + "new TelepathicEngine extraction heuristic includes highly semantic buttons." + ) + + # Instead, look for the parent Add to Saved button (which IS clickable) + save_nodes = [n for n in nodes if "row feed button save" in n["semantic_string"]] + assert len(save_nodes) >= 1, ( + f"Expected to find 'Add to Saved' button in real home feed XML. " + f"Found nodes: {[n['semantic_string'][:60] for n in nodes]}" + ) + + def test_home_feed_extracts_tab_bar(self): + """ + The parser must find the bottom tab bar items (Home, Reels, Search, Profile). + These are critical for navigation. + """ + engine = TelepathicEngine() + xml = load_fixture("home_feed_with_ad.xml") + nodes = engine._extract_semantic_nodes(xml) + + tab_descriptions = [n["semantic_string"] for n in nodes if "tab" in n["semantic_string"].lower()] + assert any("Home" in t for t in tab_descriptions), "Must find Home tab" + assert any("Search and explore" in t for t in tab_descriptions), "Must find Search tab" + assert any("Profile" in t for t in tab_descriptions), "Must find Profile tab" + + def test_home_feed_node_count_is_realistic(self): + """ + A real Instagram home feed XML produces 20-40 interactive nodes. + If we get <10 or >100, the parser is broken. + """ + engine = TelepathicEngine() + xml = load_fixture("home_feed_with_ad.xml") + nodes = engine._extract_semantic_nodes(xml) + + assert 10 <= len(nodes) <= 100, ( + f"Expected 10-100 interactive nodes from real XML, got {len(nodes)}. " + f"Parser may be too strict or too lenient." + ) + + def test_explore_feed_extracts_like_button(self): + """ + In the real Explore/Reels feed, the Like button has id 'like_button' + and description 'Like'. The parser must find it. + """ + engine = TelepathicEngine() + xml = load_fixture("explore_feed_reel.xml") + nodes = engine._extract_semantic_nodes(xml) + + like_nodes = [n for n in nodes + if "like" in n["semantic_string"].lower() + and "button" in n["semantic_string"].lower()] + assert len(like_nodes) >= 1, ( + f"Expected to find Like button in explore feed. " + f"Found: {[n['semantic_string'][:60] for n in nodes]}" + ) + + def test_explore_feed_has_fullscreen_containers(self): + """ + Verify that the parser extracts the fullscreen containers + (swipeable_nav_view_pager_inner_recycler_view, clips_viewer_view_pager) + so that the Safety Guard has something to reject. + """ + engine = TelepathicEngine() + xml = load_fixture("explore_feed_reel.xml") + nodes = engine._extract_semantic_nodes(xml) + + fullscreen = [] + for n in nodes: + m = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', n["raw_bounds"]) + if m: + l, t, r, b = map(int, m.groups()) + if (r - l) > 900 and (b - t) > 1600: + fullscreen.append(n) + + assert len(fullscreen) >= 2, ( + f"Expected at least 2 fullscreen containers in explore XML " + f"(swipeable pager + recycler view). Got {len(fullscreen)}." + ) + + +class TestSafetyGuard: + """ + Tests the VLM Safety Guard against nodes extracted from REAL XML. + Ensures that if a hallucinating VLM picks a fullscreen container, + the guard catches it. + """ + + @pytest.fixture(autouse=True) + def setup_real_nodes(self): + """Pre-parse real XML nodes BEFORE any mocking happens.""" + engine = TelepathicEngine() + explore_xml = load_fixture("explore_feed_reel.xml") + self.explore_nodes = engine._extract_semantic_nodes(explore_xml) + + @patch('builtins.open', new_callable=MagicMock) + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('os.path.exists') + def test_real_explore_fullscreen_container_rejected(self, mock_exists, mock_query, mock_open): + """ + Feed real explore XML nodes to the VLM fallback. + Force VLM to pick the fullscreen swipeable_nav_view_pager. + The safety guard MUST reject it. + """ + mock_exists.return_value = False + engine = TelepathicEngine() + device = MagicMock() + device.deviceV2.screenshot = MagicMock() + mock_open.return_value.__enter__.return_value.read.return_value = b'fakeimage' + + nodes = self.explore_nodes + + # Find any fullscreen structural container + container_idx = None + for i, n in enumerate(nodes): + m = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', n["raw_bounds"]) + if m: + l, t, r, b = map(int, m.groups()) + if (r - l) > 900 and (b - t) > 1600: + # It's not a media container (no vid/clip keyword) + sem = n["semantic_string"].lower() + if not any(k in sem for k in ["vid", "img", "image", "clip", "reel"]): + container_idx = i + break + + assert container_idx is not None, ( + f"Test setup: couldn't find a non-media fullscreen container. " + f"Nodes: {[n['semantic_string'][:60] for n in nodes]}" + ) + + mock_query.return_value = json.dumps({"index": container_idx, "reason": "This looks like the like button"}) + result = engine._vision_cortex_fallback("tap like button", nodes, device) + + assert result is None, ( + f"CRITICAL: Safety guard failed on REAL XML! " + f"Accepted node {container_idx}: {nodes[container_idx]['semantic_string']}" + ) + + @patch('builtins.open', new_callable=MagicMock) + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('os.path.exists') + def test_real_explore_like_button_accepted(self, mock_exists, mock_query, mock_open): + """ + Feed real explore XML nodes. + Force VLM to pick the actual like button. + The safety guard MUST allow it through. + """ + mock_exists.return_value = False + engine = TelepathicEngine() + device = MagicMock() + device.deviceV2.screenshot = MagicMock() + mock_open.return_value.__enter__.return_value.read.return_value = b'fakeimage' + + nodes = self.explore_nodes + + # Find the like button + like_idx = None + for i, n in enumerate(nodes): + if "like" in n["semantic_string"].lower() and "button" in n["semantic_string"].lower(): + # Ensure it's a small button, not a container + m = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', n["raw_bounds"]) + if m: + l, t, r, b = map(int, m.groups()) + if (r - l) < 200 and (b - t) < 200: + like_idx = i + break + + assert like_idx is not None, ( + f"Test setup: couldn't find Like button in real explore XML. " + f"Nodes: {[n['semantic_string'][:60] for n in nodes]}" + ) + + mock_query.return_value = json.dumps({"index": like_idx, "reason": "It literally says Like"}) + result = engine._vision_cortex_fallback("tap like button", nodes, device) + + assert result is not None, "The real Like button (116x116) must be accepted" + assert nodes[like_idx]["x"] == result["x"] + assert nodes[like_idx]["y"] == result["y"] + + +class TestAdDetection: + """ + Tests ad detection against REAL XML captured from the device. + The dump.xml actually contains a real Instagram ad (hoeltlfinanzgmbh). + """ + + def test_real_explore_feed_is_not_ad(self): + """ + The explore_feed.xml is a real Reel without any ad markers. + It should NOT be flagged. + """ + from GramAddict.core.bot_flow import _detect_ad_structural + + xml = load_fixture("explore_feed_reel.xml") + assert _detect_ad_structural(xml) is False, ( + "Real explore/reel content was falsely flagged as an ad!" + ) + + +class TestFeedMarkers: + """ + Tests feed marker detection against REAL XML. + """ + + def test_real_home_feed_has_markers(self): + """The real home feed XML must match our feed markers.""" + from GramAddict.core.bot_flow import FEED_MARKERS + + xml = load_fixture("home_feed_with_ad.xml") + has_markers = any(m in xml for m in FEED_MARKERS) + assert has_markers, ( + "Real home feed XML did not match any feed markers! " + f"Markers: {FEED_MARKERS}" + ) + + def test_real_explore_feed_has_markers(self): + """The real explore feed XML must match our feed markers.""" + from GramAddict.core.bot_flow import FEED_MARKERS + + xml = load_fixture("explore_feed_reel.xml") + has_markers = any(m in xml for m in FEED_MARKERS) + assert has_markers, ( + "Real explore feed XML did not match any feed markers! " + f"Markers: {FEED_MARKERS}" + ) + +class TestTelepathicResolutionCascade: + """ + Tests that the Telepathic Engine's resolution cascade strictly enforces + cheapest-first processing (Fast Path -> Embeddings -> VLM) to avoid + token overkill and API spam. Uses real XML dumps. + """ + + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('GramAddict.core.qdrant_memory.QdrantBase._get_embedding') + def test_keyword_fast_path_bypasses_ai(self, mock_get_embedding, mock_vlm): + """ + A direct keyword match (like 'tap like button') MUST be resolved by Stage 1.5. + It must never reach the Embedding (Stage 2) or VLM (Stage 3). + """ + from GramAddict.core.telepathic_engine import TelepathicEngine + engine = TelepathicEngine() + engine._embedding_cache.clear() + engine._intent_cache.clear() + + # home_feed_with_ad.xml contains standard UI elements + xml_content = load_fixture("home_feed_with_ad.xml") + + result = engine.find_best_node(xml_content, "tap comment button") + + assert result is not None, "Failed to find the node." + assert "comment" in result["semantic"].lower(), "Did not find comment button." + assert result.get("score", 0) >= 0.4, "Fast path score ratio should be valid" + + # PROOF: Zero AI tokens used! + mock_get_embedding.assert_not_called() + mock_vlm.assert_not_called() + + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('GramAddict.core.qdrant_memory.QdrantBase._get_embedding') + def test_embedding_fallback_bypasses_vlm_if_confident(self, mock_get_embedding, mock_vlm): + """ + If we ask something without an exact keyword match, it should fail Stage 1.5, + hit Stage 2 (Embeddings), and if confident enough, avoid Stage 3 (VLM). + """ + from GramAddict.core.telepathic_engine import TelepathicEngine + engine = TelepathicEngine() + engine._embedding_cache.clear() + engine._intent_cache.clear() + + xml_content = load_fixture("home_feed_with_ad.xml") + + def fake_embed(text): + if "heart" in text.lower(): + return [1.0, 0.0] # Intent vector + if "like" in text.lower() and "button" in text.lower(): + return [0.99, 0.1] # Very similar to intent + return [0.0, 1.0] # Completely different for all other UI nodes + + mock_get_embedding.side_effect = fake_embed + + # "heart" is not mechanically in the keyword of the Like button, + # causing Keyword Path to fail. Vector Similarity will know Heart == Like. + result = engine.find_best_node(xml_content, "tap the heart symbol") + + assert result is not None, "Failed to find the node through embeddings." + assert "like" in result["semantic"].lower(), "Embeddings didn't pick the like button." + assert result.get("score", 0) >= 0.82, "Confidence threshold should be met" + + # PROOF: Embeddings matched it, VLM was NOT used + assert mock_get_embedding.call_count > 0, "Embeddings were not called" + mock_vlm.assert_not_called() + + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('GramAddict.core.qdrant_memory.QdrantBase._get_embedding') + def test_vlm_fallback_triggered_on_low_confidence(self, mock_get_embedding, mock_vlm): + """ + If Embeddings fail to find a confident match (< 0.82), it must trigger + the Stage 3 VLM fallback. + """ + from GramAddict.core.telepathic_engine import TelepathicEngine + engine = TelepathicEngine() + engine._embedding_cache.clear() + engine._intent_cache.clear() + + xml_content = load_fixture("home_feed_with_ad.xml") + + def fake_embed(text): + if "mystical" in text: + return [1.0, 0.0] + return [0.0, 1.0] + + mock_get_embedding.side_effect = fake_embed + mock_vlm.return_value = '{"index": 2, "reason": "Fallback chosen by VLM"}' + + # A mockup device is needed for VLM fallback + import unittest.mock + device = unittest.mock.MagicMock() + + result = engine.find_best_node(xml_content, "tap the mystical artifact", device=device) + + # It might return a result (from VLM) or None depending on the XML structure, + # but we ONLY care that VLM was indeed queried! + mock_get_embedding.assert_called() + mock_vlm.assert_called_once() + diff --git a/tests/integration/test_telepathic_engine_vlm.py b/tests/integration/test_telepathic_engine_vlm.py new file mode 100644 index 0000000..c113f2b --- /dev/null +++ b/tests/integration/test_telepathic_engine_vlm.py @@ -0,0 +1,616 @@ +""" +Test Suite: VLM Bombproofing & Interaction Integrity +===================================================== +TDD validation that the Telepathic Engine and bot_flow interaction loop +are structurally safe against VLM hallucinations, cache poisoning, +and Darwin-induced context loss. +""" +import pytest +import re +from unittest.mock import MagicMock, patch, call +import json +from GramAddict.core.telepathic_engine import TelepathicEngine + + +# ── Shared Fixtures ── + +def mock_device(width=1080, height=2400): + device = MagicMock() + device.get_info.return_value = {"displayWidth": width, "displayHeight": height} + device.deviceV2.screenshot = MagicMock() + device.cm_to_pixels = MagicMock(side_effect=lambda cm: int(cm * 160)) # ~160px per cm + device._get_current_app.return_value = "com.instagram.android" + device.app_id = "com.instagram.android" + return device + + +def make_node(x, y, bounds, semantic, text="", desc=""): + """Helper to construct realistic UI nodes.""" + node = { + "x": x, "y": y, + "raw_bounds": bounds, + "semantic_string": semantic, + "original_attribs": {"text": text, "desc": desc, "resource-id": "com.instagram.android:id/dummy"}, + "resource_id": "com.instagram.android:id/dummy" + } + # Parse bounds to calculate area for VLM structural guards + m = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds) + if m: + l, t, r, b = map(int, m.groups()) + width = r - l + height = b - t + node["width"] = width + node["height"] = height + node["area"] = width * height + else: + node["width"] = 0 + node["height"] = 0 + node["area"] = 0 + return node + + +# Realistic node sets extracted from live Instagram XML dumps +EXPLORE_FEED_NODES = [ + make_node(540, 1250, "[0,200][1080,2300]", + "id context: 'swipeable nav view pager inner recycler view'"), + make_node(100, 2200, "[50,2150][150,2250]", + "description: 'Search and explore', id context: 'search tab'"), + make_node(540, 2200, "[490,2150][590,2250]", + "description: 'Reels', id context: 'reels tab'"), + make_node(940, 2200, "[890,2150][990,2250]", + "description: 'Profile', id context: 'profile tab'"), +] + +REEL_POST_NODES = [ + make_node(540, 1200, "[0,0][1080,2200]", + "id context: 'clips video container'"), + make_node(1020, 800, "[980,760][1060,840]", + "description: 'Like', id context: 'row feed button like'"), + make_node(1020, 920, "[980,880][1060,960]", + "description: 'Comment', id context: 'row feed button comment'"), + make_node(1020, 1040, "[980,1000][1060,1080]", + "description: 'Share', id context: 'row feed button share'"), + make_node(180, 2100, "[50,2060][310,2140]", + "text: 'super_azores', description: 'super_azores'", text="super_azores"), +] + +PHOTO_POST_NODES = [ + make_node(540, 850, "[0,400][1080,1300]", + "id context: 'row feed photo imageview'"), + make_node(100, 1350, "[50,1310][150,1390]", + "description: 'Like', id context: 'row feed button like'"), + make_node(200, 1350, "[150,1310][250,1390]", + "description: 'Comment', id context: 'row feed button comment'"), +] + +PROFILE_EDIT_NODES = [ + make_node(540, 300, "[0,50][1080,550]", + "id context: 'profile header container'"), + make_node(540, 650, "[100,600][980,700]", + "text: 'Edit profile', id context: 'edit profile button'", text="Edit profile"), + make_node(540, 800, "[100,750][980,850]", + "text: 'Share profile', id context: 'share profile button'", text="Share profile"), +] + + +class TestVLMHallucinationRejection: + """ + Tests that the engine rejects VLM responses pointing to massive + structural containers instead of small interactive elements. + """ + + @patch('builtins.open', new_callable=MagicMock) + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('os.path.exists') + def test_recycler_view_hallucination_is_rejected(self, mock_exists, mock_query, mock_open): + """ + Exact reproduction of the bug from log 2026-04-13 17:22:31: + VLM picked node 0 ('swipeable nav view pager inner recycler view') + for intent 'tap like button'. Must be rejected. + """ + mock_exists.return_value = False + engine = TelepathicEngine() + device = mock_device() + mock_open.return_value.__enter__.return_value.read.return_value = b'fakeimage' + + mock_query.return_value = '{"index": 0, "reason": "I think this is it"}' + + result = engine._vision_cortex_fallback("tap like button", EXPLORE_FEED_NODES, device) + + assert result is None, ( + f"CRITICAL: Engine accepted a fullscreen recycler view as 'like button'! " + f"Got: {result}" + ) + + @patch('builtins.open', new_callable=MagicMock) + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('os.path.exists') + def test_frame_layout_hallucination_is_rejected(self, mock_exists, mock_query, mock_open): + """ + A different structural container variant: FrameLayout that spans + the full display. Must also be rejected. + """ + mock_exists.return_value = False + engine = TelepathicEngine() + device = mock_device() + mock_open.return_value.__enter__.return_value.read.return_value = b'fakeimage' + + nodes = [ + make_node(540, 1200, "[0,0][1080,2400]", + "id context: 'action bar root'"), + make_node(100, 1350, "[50,1310][150,1390]", + "description: 'Like', id context: 'row feed button like'"), + ] + + mock_query.return_value = '{"index": 0, "reason": "action bar seems right"}' + result = engine._vision_cortex_fallback("tap like button", nodes, device) + + assert result is None, ( + f"CRITICAL: Engine accepted a fullscreen FrameLayout as 'like button'! " + f"Got: {result}" + ) + + @patch('builtins.open', new_callable=MagicMock) + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('os.path.exists') + def test_video_container_is_allowed_for_media_intent(self, mock_exists, mock_query, mock_open): + """ + Fullscreen video containers (clips_video_container) are legitimate + tap targets for intents like 'pause reel' or 'tap the reel video'. + """ + mock_exists.return_value = False + engine = TelepathicEngine() + device = mock_device() + mock_open.return_value.__enter__.return_value.read.return_value = b'fakeimage' + + mock_query.return_value = '{"index": 0, "reason": "Tapping the video to pause"}' + result = engine._vision_cortex_fallback("tap the reel video", REEL_POST_NODES, device) + + assert result is not None, "Video container tap should be allowed for media intents" + assert result["x"] == 540 + assert result["y"] == 1200 + + @patch('builtins.open', new_callable=MagicMock) + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('os.path.exists') + def test_correct_like_button_is_accepted(self, mock_exists, mock_query, mock_open): + """ + When VLM correctly identifies the small like button (80x80), + it must be accepted without interference from the safety guard. + """ + mock_exists.return_value = False + engine = TelepathicEngine() + device = mock_device() + mock_open.return_value.__enter__.return_value.read.return_value = b'fakeimage' + + # VLM returns index 1 — the correct, tiny Like button + mock_query.return_value = '{"index": 1, "reason": "It says Like and has the heart icon"}' + result = engine._vision_cortex_fallback("tap like button", REEL_POST_NODES, device) + + assert result is not None, "Correct like button should be accepted" + assert result["x"] == 1020 + assert result["y"] == 800 + + @patch('builtins.open', new_callable=MagicMock) + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('os.path.exists') + def test_comment_button_is_accepted(self, mock_exists, mock_query, mock_open): + """Correct comment button selection on a Reel post.""" + mock_exists.return_value = False + engine = TelepathicEngine() + device = mock_device() + mock_open.return_value.__enter__.return_value.read.return_value = b'fakeimage' + + mock_query.return_value = '{"index": 2, "reason": "Comment button"}' + result = engine._vision_cortex_fallback("tap comment button", REEL_POST_NODES, device) + + assert result is not None + assert result["x"] == 1020 + assert result["y"] == 920 + + @patch('builtins.open', new_callable=MagicMock) + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('os.path.exists') + def test_photo_imageview_container_not_blocked(self, mock_exists, mock_query, mock_open): + """ + A photo imageview is large (~900x900) but NOT fullscreen. + It should NOT trigger the safety guard. + """ + mock_exists.return_value = False + engine = TelepathicEngine() + device = mock_device() + mock_open.return_value.__enter__.return_value.read.return_value = b'fakeimage' + + mock_query.return_value = '{"index": 0, "reason": "Double tap to like the photo"}' + result = engine._vision_cortex_fallback("double tap photo to like", PHOTO_POST_NODES, device) + + assert result is not None, ( + "Photo imageview (1080x900) should NOT be blocked — it's a valid media target" + ) + + +class TestTelepathicMemoryPoisoning: + """ + Tests that the cache (telepathic_memory.json) never stores + hallucinated or rejected VLM decisions. + """ + + @patch('builtins.open', new_callable=MagicMock) + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('os.path.exists') + def test_rejected_hallucination_is_never_cached(self, mock_exists, mock_query, mock_open): + """ + When a VLM hallucination is rejected by the safety guard, + it must NOT be written to telepathic_memory.json. + """ + mock_exists.return_value = False + engine = TelepathicEngine() + device = mock_device() + mock_open.return_value.__enter__.return_value.read.return_value = b'fakeimage' + + mock_query.return_value = '{"index": 0, "reason": "I think this is it"}' + result = engine._vision_cortex_fallback("tap like button", EXPLORE_FEED_NODES, device) + + assert result is None, "Hallucination should be rejected" + + # Verify that open() was never called in WRITE mode ("w") for the cache file + write_calls = [ + c for c in mock_open.call_args_list + if len(c[0]) >= 2 and c[0][1] == "w" and "telepathic_memory.json" in c[0][0] + ] + assert len(write_calls) == 0, ( + f"CRITICAL: A rejected hallucination was written to cache! Write calls: {write_calls}" + ) + + @patch('builtins.open', new_callable=MagicMock) + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('os.path.exists') + def test_valid_decision_is_tracked_but_not_cached(self, mock_exists, mock_query, mock_open): + """ + When a VLM correctly identifies a valid, small button, + it SHOULD be tracked, but NOT written to telepathic_memory.json + until explicit confirmation (bot_flow -> confirm_click). + """ + mock_exists.return_value = False + engine = TelepathicEngine() + device = mock_device() + mock_open.return_value.__enter__.return_value.read.return_value = b'fakeimage' + + # VLM correctly selects the tiny like button (node 1) + mock_query.return_value = '{"index": 1, "reason": "Like button"}' + result = engine._vision_cortex_fallback("tap like button", REEL_POST_NODES, device) + + assert result is not None, "Valid like button should be accepted" + + # Verify cache was NOT written immediately to prevent poisoning + write_calls = [ + c for c in mock_open.call_args_list + if len(c[0]) >= 2 and c[0][1] == "w" + ] + assert len(write_calls) == 0, ( + "VLM decision should NOT be saved to cache immediately to prevent poisoning!" + ) + + # Verify it is tracked + assert TelepathicEngine._last_click_context is not None + assert TelepathicEngine._last_click_context["intent"] == "tap like button" + + +class TestTelepathicMemoryRecall: + """ + Tests that the cache short-circuits correctly and never + recalls a stale/wrong semantic match. + """ + + @patch('GramAddict.core.telepathic_engine.TelepathicEngine._extract_semantic_nodes') + @patch('builtins.open', new_callable=MagicMock) + @patch('os.path.exists') + def test_cache_hit_returns_instantly(self, mock_exists, mock_open, mock_extract): + """ + If the telepathic memory already contains a hit for this intent, + it must return immediately WITHOUT taking a screenshot or calling VLM. + """ + mock_exists.return_value = True + engine = TelepathicEngine() + device = mock_device() + mock_extract.return_value = REEL_POST_NODES + + # Simulate a cached memory file + cache_data = { + "tap like button": ["description: 'Like', id context: 'row feed button like'"] + } + mock_open.return_value.__enter__.return_value.read.return_value = json.dumps(cache_data).encode() + + # Provide nodes that match the cached semantic + result = engine.find_best_node("", "tap like button", min_confidence=0.82, device=device) + + assert result is not None, "Cache hit should return a result" + assert result["x"] == 1020 + assert result["y"] == 800 + assert result["score"] == 1.0 + + # Screenshot should NEVER have been called (the early-return optimization) + device.deviceV2.screenshot.assert_not_called() + + @patch('GramAddict.core.telepathic_engine.TelepathicEngine._extract_semantic_nodes') + @patch('builtins.open', new_callable=MagicMock) + @patch('os.path.exists') + def test_cache_miss_does_not_match_wrong_intent(self, mock_exists, mock_open, mock_extract): + """ + Cached memory for 'tap like button' must NOT be used when the + intent is 'tap comment button'. + """ + mock_exists.return_value = True + engine = TelepathicEngine() + device = mock_device() + mock_extract.return_value = REEL_POST_NODES + + cache_data = { + "tap like button": ["description: 'Like', id context: 'row feed button like'"] + } + mock_open.return_value.__enter__.return_value.read.return_value = json.dumps(cache_data).encode() + + # We ask for "comment" but only "like" is cached — no early return + # Mock VLM fallback so it doesn't crash + with patch.object(engine, '_vision_cortex_fallback', return_value={"x": 999, "y": 999, "score": 1.0}): + result = engine.find_best_node("", "tap comment button", min_confidence=0.82, device=device) + + # It should NOT return the like button coordinates + if result is not None: + assert result["y"] != 800, ( + "CRITICAL: Cache returned like button coordinates for a comment intent!" + ) + + +class TestDarwinScrollSafety: + """ + Tests that Darwin's 'cognitive wobble' and 'non-linear scroll' + don't produce scroll distances large enough to leave the current post. + """ + + def test_back_swipe_distance_is_bounded(self): + """ + The back-swipe (cognitive wobble) must never exceed 1.5cm (~240px). + Anything larger risks scrolling past the current post entirely. + """ + from GramAddict.core.darwin_engine import DarwinEngine + + # Run 200 Monte Carlo iterations to catch edge cases + max_observed_distance = 0 + for _ in range(200): + # The back-swipe distance is: cm_to_pixels(uniform(0.8, 1.2)) + # At 160px/cm ≈ 128 to 192 pixels. Must stay under 240px. + distance_cm = __import__('random').uniform(0.8, 1.2) + distance_px = int(distance_cm * 160) # approximate px/cm + max_observed_distance = max(max_observed_distance, distance_px) + + assert max_observed_distance <= 240, ( + f"Back-swipe distance reached {max_observed_distance}px! " + f"Max allowed is 240px to prevent scrolling off the current post." + ) + + def test_scroll_velocity_never_causes_multi_post_skip(self): + """ + The non-linear scroll in execute_proof_of_resonance must not + produce a swipe distance exceeding the screen height, which would + skip multiple posts at once. + """ + # scroll_velocity bounds: (0.1, 2.0) + # distance = cm_to_pixels(uniform(4.0, 7.0)) * velocity + # Worst case: 7cm * 2.0 velocity * 160px/cm = 2240px + # Screen height is 2400px — this is dangerously close! + + max_distance_px = 0 + for _ in range(500): + velocity = __import__('random').uniform(0.1, 2.0) + base_cm = __import__('random').uniform(4.0, 7.0) + distance_px = int(base_cm * 160 * velocity) + max_distance_px = max(max_distance_px, distance_px) + + screen_height = 2400 + assert max_distance_px < screen_height, ( + f"Darwin scroll distance reached {max_distance_px}px which exceeds " + f"screen height {screen_height}px! This would skip multiple posts." + ) + + +class TestFeedMarkerValidation: + """ + Tests that the feed marker self-check in bot_flow correctly + identifies when the bot is on a post vs. lost. + """ + + def test_reel_feed_markers_detected(self): + """ + A Reel post contains 'clips_media_component' which is in FEED_MARKERS. + """ + from GramAddict.core.bot_flow import FEED_MARKERS + + fake_xml = """ + + + + + """ + has_markers = any(m in fake_xml for m in FEED_MARKERS) + assert has_markers, "Reel XML should match feed markers via 'clips_media_component'" + + def test_photo_feed_markers_detected(self): + """ + A photo post contains 'row_feed_photo_imageview' in FEED_MARKERS. + """ + from GramAddict.core.bot_flow import FEED_MARKERS + + fake_xml = """ + + + + + """ + has_markers = any(m in fake_xml for m in FEED_MARKERS) + assert has_markers, "Photo post XML should match feed markers via 'row_feed_photo_imageview'" + + def test_profile_page_has_no_feed_markers(self): + """ + A profile page must NOT match any feed markers. + This is the bug scenario: the bot tapped a user tag, ended up on + a profile page, and then tried to interact with non-existent posts. + """ + from GramAddict.core.bot_flow import FEED_MARKERS + + fake_profile_xml = """ + + + + + + + """ + has_markers = any(m in fake_profile_xml for m in FEED_MARKERS) + assert not has_markers, ( + "Profile page XML must NOT match feed markers! " + "If it does, the bot would try to like/interact on a profile page." + ) + + def test_edit_profile_page_has_no_feed_markers(self): + """ + The edit profile page (where the bot got stuck) must NOT match markers. + """ + from GramAddict.core.bot_flow import FEED_MARKERS + + fake_edit_xml = """ + + + + + + """ + has_markers = any(m in fake_edit_xml for m in FEED_MARKERS) + assert not has_markers, ( + "Edit profile page must NOT match feed markers! " + "The bot was getting stuck here because it blindly tapped center-screen." + ) + + def test_explore_grid_has_no_feed_markers(self): + """ + The Explore grid (before opening a post) must NOT match feed markers. + The bot should only enter the interaction loop AFTER tapping into a post. + """ + from GramAddict.core.bot_flow import FEED_MARKERS + + fake_explore_grid_xml = """ + + + + + + + """ + has_markers = any(m in fake_explore_grid_xml for m in FEED_MARKERS) + assert not has_markers, ( + "Explore grid must NOT match feed markers — the bot isn't on a post yet." + ) + + +class TestAdDetection: + """ + Tests that ad detection is accurate and doesn't flag organic posts. + """ + + def test_sponsored_post_detected(self): + """A post with ad_cta_button is detected as an ad.""" + from GramAddict.core.bot_flow import _detect_ad_structural + + ad_xml = """ + + + + + """ + assert _detect_ad_structural(ad_xml) is True + + def test_organic_post_not_flagged(self): + """A normal post without ad markers is NOT flagged as adv.""" + from GramAddict.core.bot_flow import _detect_ad_structural + + organic_xml = """ + + + + + + + """ + assert _detect_ad_structural(organic_xml) is False, ( + "Organic post with location secondary_label must NOT be marked as ad!" + ) + + def test_sponsored_secondary_label_detected(self): + """An ad with a secondary_label containing 'Ad' should be flagged.""" + from GramAddict.core.bot_flow import _detect_ad_structural + + # Extracted directly from: manual_interrupt__2026-04-13_23-55-33.xml + ad_xml = """ + + + + + """ + assert _detect_ad_structural(ad_xml) is True, "Failed to detect an ad via the secondary_label 'Ad' badge!" + + def test_organic_post_with_music_not_flagged(self): + """A post with a music track attribution must NOT be flagged.""" + from GramAddict.core.bot_flow import _detect_ad_structural + + music_xml = """ + + + + + + """ + assert _detect_ad_structural(music_xml) is False, ( + "Organic reel with music attribution must NOT be marked as ad!" + ) + + @patch('builtins.open', new_callable=MagicMock) + @patch('GramAddict.core.telepathic_engine.query_telepathic_llm') + @patch('os.path.exists') + def test_vlm_receives_semantically_relevant_nodes_first(self, mock_exists, mock_query, mock_open): + """ + If the target node is late in the XML hierarchy (e.g. node 40), + it MUST be passed to the VLM. The VLM should not be forced to + guess from the first 10 random XML nodes. + """ + mock_exists.return_value = False + engine = TelepathicEngine() + device = mock_device() + mock_open.return_value.__enter__.return_value.read.return_value = b'fakeimage' + + # Create 15 garbage nodes + nodes = [] + for i in range(15): + nodes.append(make_node(10, 10, "[0,0][20,20]", f"garbage node {i}")) + + # Target node is at the end (index 15) + target_node = make_node(500, 500, "[400,400][600,600]", "description: 'Like', id context: 'row feed button like'") + nodes.append(target_node) + + # We simulate that the embedding engine scores the target_node highest + with patch.object(engine, '_cosine_similarity', side_effect=lambda v1, v2: 1.0 if v1 == v2 else 0.0): + with patch.object(engine, '_get_cached_embedding', return_value=[0.1]*768) as mock_get_embed: + # Make target node have same embedding as intent + def fake_embed(text, is_intent=False): + if is_intent or "Like" in text: return [1.0]*768 + return [0.0]*768 + mock_get_embed.side_effect = fake_embed + + # VLM should select index 0, because the target_node should be SORTED to the top! + mock_query.return_value = '{"index": 0, "reason": "Like button"}' + + with patch.object(engine, '_extract_semantic_nodes', return_value=nodes): + # min_confidence=1.1 to force fallback + result = engine.find_best_node("", "tap like button", min_confidence=1.1, device=device) + + assert result is not None, "VLM should have returned a result" + assert result["x"] == 500 and result["y"] == 500, "VLM did not receive the best semantic candidates!" diff --git a/tests/integration/test_telepathic_keyword.py b/tests/integration/test_telepathic_keyword.py new file mode 100644 index 0000000..8f9a210 --- /dev/null +++ b/tests/integration/test_telepathic_keyword.py @@ -0,0 +1,31 @@ +import pytest +from GramAddict.core.telepathic_engine import TelepathicEngine + +def test_keyword_fast_path_no_feed_pollution(): + engine = TelepathicEngine() + + # A generic Feed post that used to spoof the 'home' keyword due to 'row feed photo' + feed_post_node = { + "x": 100, "y": 200, "area": 500, + "semantic_string": "description: 'Profile picture of ericrubens', id context: 'row feed photo profile imageview'", + "resource_id": "row_feed_photo_profile_imageview", + "original_attribs": {"desc": "Profile picture of ericrubens", "text": ""} + } + + # The actual Home Tab button + home_tab_node = { + "x": 100, "y": 2300, "area": 300, + "semantic_string": "description: 'Home', id context: 'tab bar'", + "resource_id": "tab_avatar", + "original_attribs": {"desc": "Home", "text": ""} + } + + nodes = [feed_post_node, home_tab_node] + + # Intention is to tap the home tab + result = engine._keyword_match_score("tap home tab", nodes) + + assert result is not None + # Verify it matched the actual home tab and NOT the feed post + assert result["semantic"] == "description: 'Home', id context: 'tab bar'" + diff --git a/tests/integration/test_unfollow_loop.py b/tests/integration/test_unfollow_loop.py new file mode 100644 index 0000000..eb92260 --- /dev/null +++ b/tests/integration/test_unfollow_loop.py @@ -0,0 +1,80 @@ +import pytest +from unittest.mock import MagicMock, patch +from GramAddict.core.unfollow_engine import _run_zero_latency_unfollow_loop + +@pytest.fixture +def unfollow_mock_dependencies(): + device = MagicMock() + zero_engine = MagicMock() + nav_graph = MagicMock() + + class ConfigArgs: + total_unfollows_limit = 5 + + configs = MagicMock() + configs.args = ConfigArgs() + + session_state = MagicMock() + session_state.check_limit.return_value = (False, False, False, False) + session_state.totalUnfollowed = 0 + + telepathic = MagicMock() + dopamine = MagicMock() + dopamine.is_app_session_over.side_effect = [False, False, True] + dopamine.wants_to_change_feed.return_value = False + dopamine.boredom = 0.0 + + cognitive_stack = { + "telepathic": telepathic, + "dopamine": dopamine, + } + + return device, zero_engine, nav_graph, configs, session_state, cognitive_stack + +def test_unfollow_engine_basic_loop(unfollow_mock_dependencies): + device, zero_engine, nav_graph, configs, session_state, cognitive_stack = unfollow_mock_dependencies + + telepathic = cognitive_stack["telepathic"] + + # First node gives a "Following" button + telepathic._extract_semantic_nodes.side_effect = [ + [{"x": 100, "y": 200, "skip": False, "bounds": "..."}], # following button + [{"x": 150, "y": 250, "skip": False}], # confirm dialog + [], # second iteration + [] + ] + + with patch("GramAddict.core.unfollow_engine._humanized_scroll_down") as mock_scroll, \ + patch("GramAddict.core.bot_flow.sleep"), \ + patch("GramAddict.core.bot_flow._humanized_click") as mock_click: + + res = _run_zero_latency_unfollow_loop(device, zero_engine, nav_graph, configs, session_state, "FollowingList", cognitive_stack) + + assert mock_click.call_count == 2 # Clicked following THEN clicked confirm + assert session_state.totalUnfollowed == 1 + assert res == "SESSION_OVER" + +def test_unfollow_engine_chaos_mode(unfollow_mock_dependencies): + device, zero_engine, nav_graph, configs, session_state, cognitive_stack = unfollow_mock_dependencies + + telepathic = cognitive_stack["telepathic"] + + # Simulate Telepathic failure / missing nodes + telepathic._extract_semantic_nodes.side_effect = Exception("UI DUMP CORRUPTED") + + with patch("GramAddict.core.unfollow_engine._humanized_scroll_down") as mock_scroll, \ + patch("GramAddict.core.bot_flow.sleep"), \ + patch("GramAddict.core.bot_flow._humanized_click") as mock_click: + + res = _run_zero_latency_unfollow_loop(device, zero_engine, nav_graph, configs, session_state, "FollowingList", cognitive_stack) + + # It should catch the exception, scroll down, and increment failed scans until it realizes context is lost + assert mock_scroll.call_count > 0 + assert res == "CONTEXT_LOST" or res == "SESSION_OVER" + +def test_unfollow_engine_limits(unfollow_mock_dependencies): + device, zero_engine, nav_graph, configs, session_state, cognitive_stack = unfollow_mock_dependencies + session_state.check_limit.return_value = (True, False, False, False) + + res = _run_zero_latency_unfollow_loop(device, zero_engine, nav_graph, configs, session_state, "FollowingList", cognitive_stack) + assert res == "BOREDOM_CHANGE_FEED" diff --git a/tests/txt/txt_empty.txt b/tests/txt/txt_empty.txt new file mode 100644 index 0000000..3f2ff2d --- /dev/null +++ b/tests/txt/txt_empty.txt @@ -0,0 +1,5 @@ + + + + + diff --git a/tests/txt/txt_ok.txt b/tests/txt/txt_ok.txt new file mode 100644 index 0000000..7e3585a --- /dev/null +++ b/tests/txt/txt_ok.txt @@ -0,0 +1,6 @@ + +Hello, test_user! How are you today? +Hello everyone! + +Goodbye, test_user! Have a great day! + diff --git a/tests/unit/test_config_effects.py b/tests/unit/test_config_effects.py new file mode 100644 index 0000000..7dd0c5a --- /dev/null +++ b/tests/unit/test_config_effects.py @@ -0,0 +1,182 @@ +import pytest +from unittest.mock import patch +from GramAddict.core.bot_flow import _interact_with_profile, _interact_with_carousel +from tests.conftest import MockArgs, MockConfigs + +@pytest.fixture(autouse=True) +def silent_sleep(monkeypatch): + import GramAddict.core.bot_flow + monkeypatch.setattr(GramAddict.core.bot_flow, "sleep", lambda x: None) + + +@patch("random.random") +def test_interact_with_profile_all_100_percent(mock_random, device, telepathic_mock, mock_logger): + # Guaranteed to pass checks + mock_random.return_value = 0.0 + + args = MockArgs( + stories_percentage=100, + stories_count="3-3", + follow_percentage=100, + likes_percentage=100, + likes_count="2-2" + ) + configs = MockConfigs(args) + from GramAddict.core.session_state import SessionState + session_state = SessionState(configs) + session_state.set_limits_session() + + _interact_with_profile(device, configs, "testuser", session_state, 0.0, mock_logger) + + # 1 target story click + 2 right-side skip clicks + 1 follow + 1 grid open + 2 post likes (double taps) + 2 scrolls + # 3 story (3 shell commands) + # 1 follow (1 shell command) + # 1 grid tap (1 shell config) + # 2 likes (Double tap = 2 shell commands each = 4 total) + # 2 scrolls (2 shell commands) + # Total shells expected: 3 + 1 + 1 + 4 + 2 = 11 + + # Check total shells + assert len(device.deviceV2.shells) == 11 + + # We no longer check explicit clicks/double_clicks array because we humanized them into shell commands. + for cmd in device.deviceV2.shells: + assert "input swipe" in cmd + +@patch("random.random") +def test_interact_with_profile_zero_percent(mock_random, device, telepathic_mock, mock_logger): + # Guaranteed to fail chance logic + mock_random.return_value = 0.99 + + args = MockArgs( + stories_percentage=0, + follow_percentage=0, + likes_percentage=0 + ) + configs = MockConfigs(args) + from GramAddict.core.session_state import SessionState + session_state = SessionState(configs) + session_state.set_limits_session() + + _interact_with_profile(device, configs, "testuser", session_state, 0.0, mock_logger) + + assert len(device.deviceV2.shells) == 0 + +@patch("random.random") +def test_interact_with_profile_mixed_probability(mock_random, device, telepathic_mock, mock_logger): + # This simulates passing the Follow and Like percentage, but failing the Story percentage. + # It ensures there are no UnboundLocalErrors when certain blocks are skipped. + def mock_random_side_effect(): + # Let's say random.random() returns a predictable sequence or just use a generator: + # 1st call: story probability (fail, e.g. 0.99 < 0.0) + # 2nd call: follow probability (pass, e.g. 0.0 < 1.0) + # 3rd call: likes probability (pass, e.g. 0.0 < 1.0) + return 0.5 + + mock_random.return_value = 0.5 + + args = MockArgs( + stories_percentage=0, # Fails (0.5 < 0) + follow_percentage=100, # Passes (0.5 < 1) + likes_percentage=100, # Passes (0.5 < 1) + likes_count="1-1" + ) + configs = MockConfigs(args) + from GramAddict.core.session_state import SessionState + session_state = SessionState(configs) + session_state.set_limits_session() + + # Should not throw any exception + _interact_with_profile(device, configs, "testuser", session_state, 0.0, mock_logger) + + # 0 stories, 1 follow, 1 like block (1 grid open + 2 double tap shells + 1 scroll) + # total shells = 1 (follow) + 1 (grid click) + 2 (1 double tap) + 1 (scroll) = 5 + assert len(device.deviceV2.shells) == 5 + +@patch("random.random") +def test_carousel_100_percent(mock_random, device, mock_logger): + mock_random.return_value = 0.0 + + args = MockArgs( + carousel_percentage=100, + carousel_count="4-4" + ) + configs = MockConfigs(args) + + _interact_with_carousel(device, configs, 0.0, mock_logger) + + assert len(device.deviceV2.shells) == 4 + for cmd in device.deviceV2.shells: + assert "swipe" in cmd + +@patch("random.random") +def test_carousel_zero_percent(mock_random, device, mock_logger): + mock_random.return_value = 0.99 + + args = MockArgs( + carousel_percentage=0, + carousel_count="4-4" + ) + configs = MockConfigs(args) + + _interact_with_carousel(device, configs, 0.0, mock_logger) + + assert len(device.deviceV2.shells) == 0 + +@patch("random.random") +def test_interact_with_profile_follow_limit_enforcement(mock_random, device, telepathic_mock, mock_logger): + # Guaranteed 100% probability + mock_random.return_value = 0.0 + + args = MockArgs( + follow_percentage=100, + total_follows_limit=0, # Set hard limit to 0 + stories_percentage=0, + likes_percentage=0 + ) + configs = MockConfigs(args) + from GramAddict.core.session_state import SessionState + + # Mocking that 1 follow was already made to exceed the 0 limit + session_state = SessionState(configs) + session_state.set_limits_session() + session_state.totalFollowed["targetuser"] = 1 + + _interact_with_profile(device, configs, "targetuser", session_state, 0.0, mock_logger) + + # Assert shells is 0 (assuming stories and likes probability mathematically default to 0 due to MockArgs empty fallback) + assert len(device.deviceV2.shells) == 0 + +@patch("random.random") +def test_interact_with_profile_likes_limit_enforcement(mock_random, device, telepathic_mock, mock_logger): + # Guaranteed 100% probability + mock_random.return_value = 0.0 + + args = MockArgs( + likes_percentage=100, + likes_count="1-1", + total_likes_limit=2, + stories_percentage=0, + follow_percentage=0 + ) + configs = MockConfigs(args) + from GramAddict.core.session_state import SessionState + + session_state = SessionState(configs) + session_state.set_limits_session() + + # Faking exhaustion of total likes limit + session_state.totalLikes = 3 + + _interact_with_profile(device, configs, "targetuser", session_state, 0.0, mock_logger) + + # Limit restricts likes block. + assert len(device.deviceV2.shells) == 0 + + +# NOTE: Repost is deeply integrated into `bot_flow._run_zero_latency_feed_loop`. We can't mock the +# entire NavGraph loop here easily because it requires massive setup, but we verified the probability +# syntax by applying the same logic as Carousel/Profile interaction. +# +# Therefore we verify it via the manual `run.py` validation. +# However, this test suite guarantees the atomic config mapping syntax is correct. diff --git a/tests/unit/test_config_persona_mapping.py b/tests/unit/test_config_persona_mapping.py new file mode 100644 index 0000000..0625ba6 --- /dev/null +++ b/tests/unit/test_config_persona_mapping.py @@ -0,0 +1,31 @@ +import pytest +import argparse +from unittest.mock import MagicMock, patch + +from GramAddict.core.resonance_engine import ResonanceEngine + +def test_config_persona_mapping(): + """Verify that bot_flow.py correctly extracts persona from config arguments.""" + from GramAddict.core.config import Config + + mock_args = argparse.Namespace() + mock_args.ai_target_audience = "travel, photography, coffee" + + configs = MagicMock() + configs.args = mock_args + configs.username = "test_bot" + + # Simulating bot_flow.py lines 61-62 + persona_raw = getattr(configs.args, "ai_target_audience", getattr(configs.args, "persona_interests", "")) + persona_interests = [p.strip() for p in persona_raw.split(",") if p.strip()] if persona_raw else [] + + assert "coffee" in persona_interests + assert len(persona_interests) == 3 + + # Ensure ResonanceEngine accepts it without type tracebacks + with patch('GramAddict.core.resonance_engine.ContentMemoryDB'), \ + patch('GramAddict.core.resonance_engine.ParasocialCRMDB'), \ + patch('GramAddict.core.resonance_engine.PersonaMemoryDB'): + + engine = ResonanceEngine(configs.username, persona_interests=persona_interests) + assert engine._persona_interests == ["travel", "photography", "coffee"] diff --git a/tests/unit/test_llm_provider.py b/tests/unit/test_llm_provider.py new file mode 100644 index 0000000..8021278 --- /dev/null +++ b/tests/unit/test_llm_provider.py @@ -0,0 +1,67 @@ +import pytest +from unittest.mock import patch, MagicMock +from GramAddict.core.llm_provider import get_model_pricing, query_llm +import GramAddict.core.llm_provider + +def test_get_model_pricing_success(): + # Reset cache + GramAddict.core.llm_provider._MODEL_PRICING_CACHE = None + + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.json.return_value = { + "data": [ + {"id": "google/gemini-3.1-flash-lite-preview", "pricing": {"prompt": "0.00000025", "completion": "0.0000015"}}, + {"id": "qwen3.5-32b", "pricing": {"prompt": "0.0000001", "completion": "0.0000002"}} + ] + } + + with patch("GramAddict.core.llm_provider.requests.get", return_value=mock_response): + pricing = get_model_pricing("google/gemini-3.1-flash-lite-preview") + assert pricing["prompt"] == "0.00000025" + assert pricing["completion"] == "0.0000015" + + # Test caching + pricing2 = get_model_pricing("google/gemini-3.1-flash-lite-preview") + # Should NOT make another request + assert mock_response.json.call_count == 1 + +def test_get_model_pricing_partial_match(): + # Reset cache + GramAddict.core.llm_provider._MODEL_PRICING_CACHE = {"google/gemini-pro": {"prompt": "0.1", "completion": "0.2"}} + + # Should match via substring + pricing = get_model_pricing("gemini-pro") + assert pricing["prompt"] == "0.1" + +def test_get_model_pricing_failure(): + GramAddict.core.llm_provider._MODEL_PRICING_CACHE = None + with patch("GramAddict.core.llm_provider.requests.get", side_effect=Exception("Network error")): + pricing = get_model_pricing("some-model") + assert pricing == {} + +def test_query_llm_cost_calculation(): + # Set cache directly + GramAddict.core.llm_provider._MODEL_PRICING_CACHE = { + "test-model": {"prompt": "1.0", "completion": "2.0"} + } + + mock_post_response = MagicMock() + mock_post_response.status_code = 200 + mock_post_response.json.return_value = { + "choices": [{"message": {"content": "response text"}}], + "usage": {"prompt_tokens": 5, "completion_tokens": 10, "total_tokens": 15} + } + + with patch("GramAddict.core.llm_provider.requests.post", return_value=mock_post_response) as mock_post: + with patch("GramAddict.core.llm_provider.logger.info") as mock_logger: + with patch.dict("os.environ", {"OPENROUTER_API_KEY": "test_key"}): + res = query_llm("https://openrouter.ai/api/v1/chat/completions", "test-model", "hello", format_json=False) + + assert res["response"] == "response text" + + # Check that logging included the calculated cost + # prompt = 5 * 1.0 = 5.0 + # completion = 10 * 2.0 = 20.0 + # total = 25.0 + mock_logger.assert_called_with("đŸĒ™ [LLM Burn] test-model -> In: 5 | Out: 10 | Total: 15 | 💸 Cost: $25.000000", extra={"color": "\x1b[38;5;208m\x1b[1m"}) diff --git a/tests/unit/test_qdrant_memory.py b/tests/unit/test_qdrant_memory.py new file mode 100644 index 0000000..2393f75 --- /dev/null +++ b/tests/unit/test_qdrant_memory.py @@ -0,0 +1,43 @@ +import pytest +from unittest.mock import patch, MagicMock + +# Attempt to load the module +from GramAddict.core.qdrant_memory import UIMemoryDB + +class DummyMemory(UIMemoryDB): + def __init__(self): + # Prevent actual QdrantClient initialization for offline tests + self.client = None + self.collection_name = "test_collection" + +def test_decay_confidence_signature(): + """Ensure decay_confidence doesn't crash from legacy plugins passing xml_context.""" + mem = DummyMemory() + + # Mock _adjust_confidence to just capture arguments + mem._adjust_confidence = MagicMock() + + # Legacy caller pattern A (positional intent and amount) + mem.decay_confidence("my_intent", 0.40) + # Wait, passing positional "my_intent", 0.40 makes `args[0] = "my_intent"`, `args[1] = 0.40`. + # kwargs.get("amount") is 0.25 (default). But if passed positionally, args[1] was xml_context + # in legacy! Let's ensure it doesn't crash. + + # Legacy caller pattern B (explicit kwargs) + mem.decay_confidence(intent="my_intent", amount=0.40) + mem._adjust_confidence.assert_called_with("my_intent", -0.40) + + # Legacy caller pattern C (positional with string where amount should be) + mem.decay_confidence("my_intent", "xml_context_string") + mem._adjust_confidence.assert_called_with("my_intent", -0.50) + + # Legacy caller pattern D (kwargs with xml_context) + mem.decay_confidence(intent="my_intent", xml_context="", amount=0.30) + mem._adjust_confidence.assert_called_with("my_intent", -0.30) + +def test_boost_confidence_signature(): + mem = DummyMemory() + mem._adjust_confidence = MagicMock() + + mem.boost_confidence("intent", "xml_string", 0.5) + mem._adjust_confidence.assert_called_with("intent", 0.15) # Because "xml_string" fails float conversion, defaults to 0.15 diff --git a/tests/unit/test_qdrant_vector_dims.py b/tests/unit/test_qdrant_vector_dims.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/unit/test_session_limits_evaluation.py b/tests/unit/test_session_limits_evaluation.py new file mode 100644 index 0000000..3740d06 --- /dev/null +++ b/tests/unit/test_session_limits_evaluation.py @@ -0,0 +1,23 @@ +def test_global_session_limit_evaluation(mock_logger): + from GramAddict.core.session_state import SessionState + from tests.conftest import MockArgs, MockConfigs + + args = MockArgs( + total_likes_limit=100, + total_follows_limit=100, + total_interactions_limit=1000 + ) + configs = MockConfigs(args) + session_state = SessionState(configs) + session_state.set_limits_session() + + # Simulate a fresh session - Limit should NOT be reached + limit_tuple_clean = session_state.check_limit(SessionState.Limit.ALL) + assert not any(limit_tuple_clean), "Fresh session should not evaluate to true for limits" + + # Exhaust global limit + for _ in range(1001): + session_state.add_interaction("Feed", succeed=True, followed=False, scraped=False) + + limit_tuple_exhausted = session_state.check_limit(SessionState.Limit.ALL) + assert any(limit_tuple_exhausted), "Exhausted session MUST evaluate to true for limits" diff --git a/vlm_context.jpg b/vlm_context.jpg new file mode 100644 index 0000000..0b15cb2 Binary files /dev/null and b/vlm_context.jpg differ