### Clone AURA Repository and Setup Environment

Source: https://github.com/abhishek-pandey7/aura---automated-realtime-assistant/blob/main/README.md

Clone the AURA repository, navigate into the directory, copy the example environment file, and activate the virtual environment.

```bash
git clone https://github.com/abhishek-pandey7/AURA---Automated-Realtime-Assistant
cd AURA---Automated-Realtime-Assistant
cp .env.example .env
```

--------------------------------

### macOS/Linux Automated Installation and Activation

Source: https://github.com/abhishek-pandey7/aura---automated-realtime-assistant/blob/main/README.md

Execute the automated setup script for macOS/Linux, then activate the virtual environment and run AURA.

```bash
bash install.sh
source .venv/bin/activate
aura run
```

--------------------------------

### Manual Dependency Installation

Source: https://github.com/abhishek-pandey7/aura---automated-realtime-assistant/blob/main/README.md

Manually create a virtual environment, activate it, install AURA in editable mode, and install Playwright browser binaries.

```bash
python3 -m venv .venv
source .venv/bin/activate        # Windows: .venv\Scripts\activate
pip install -e .
playwright install chromium      # To support browser tooling
```

--------------------------------

### Windows Automated Installation and Activation

Source: https://github.com/abhishek-pandey7/aura---automated-realtime-assistant/blob/main/README.md

Run the automated setup batch file for Windows, activate the virtual environment, and then execute AURA.

```bat
install.bat
.venv\Scripts\activate
aura run
```

--------------------------------

### AURA CLI Entry Point Examples

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Common command-line invocations for AURA, including interactive sessions, single-goal execution, imitation learning, and version checking.

```bash
# Start an interactive session (REPL)
aura run
```

```bash
# Run a single goal non-interactively and exit (useful for scripting / CI)
aura run "create a Flask app with a /ping endpoint, write tests, run them"
```

```bash
# Record actions and synthesize a new macro tool
aura learn "check my bank balance"
```

```bash
# Show version
aura version
```

--------------------------------

### AURA Configuration (.env) Example

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Environment variables for configuring AURA's LLM endpoint and safety settings. Copy from `.env.example` and fill in your values.

```bash
# .env — copy from .env.example and fill in your values
INFERX_BASE_URL=https://api.openai.com/v1     # Any OpenAI-compatible base URL
INFERX_API_KEY=sk-...
INFERX_MODEL=gemma-4-31b                       # Model name at the endpoint
AURA_SAFE_MODE=true                            # true = prompt before destructive actions
```

--------------------------------

### Windows PyAudio Installation Workaround

Source: https://github.com/abhishek-pandey7/aura---automated-realtime-assistant/blob/main/README.md

If PyAudio fails to install via standard pip channels on Windows, use pipwin to install the pre-compiled wheel.

```bat
pip install pipwin
pipwin install pyaudio
```

--------------------------------

### AURA Configuration (Python) Example

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Accessing AURA's configuration values programmatically. These are exposed project-wide from the `aura.config` module.

```python
# aura/config.py exposes these values project-wide
from aura.config import INFERX_BASE_URL, INFERX_API_KEY, INFERX_MODEL, SAFE_MODE, VERSION

print(VERSION)          # "0.1.0"
print(SAFE_MODE)        # True / False (from AURA_SAFE_MODE env var)
```

--------------------------------

### AURA Task Planner (`aura.planner.plan`) Example

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Using the `plan` function to break down a natural-language goal into a list of executable subtask strings. This function calls an LLM and falls back to treating the entire goal as one task if the LLM is unavailable.

```python
from aura.planner import plan

goal  = "build a Flask REST API with /ping and /echo endpoints, add pytest tests, run them"
tasks = plan(goal, cwd="/home/user/projects")

for i, t in enumerate(tasks, 1):
    print(f"{i}. {t}")
# 1. Create project directory and initialize app.py and requirements.txt
# 2. Implement Flask app with /ping and /echo endpoints
# 3. Write pytest test suite covering both endpoints
# 4. Run pytest and self-correct any failures until all tests pass
```

--------------------------------

### Example AURA Execution Trace

Source: https://github.com/abhishek-pandey7/aura---automated-realtime-assistant/blob/main/README.md

Illustrates a typical execution flow where AURA receives a goal, creates a plan, and iteratively acts, observes, and self-corrects until the goal is achieved.

```text
$ aura run

> Build a simple Flask web hook, write tests, run them, and ensure it passes.

Plan
  1. Create project directory and initialize Python files.
  2. Implement Flask app with a basic POST endpoint.
  3. Write pytest test suite.
  4. Run tests and self-correct any failures.

Action      bash         $ mkdir hook_test && cd hook_test
Action      write_file   hook_test/app.py
Action      write_file   hook_test/test_app.py
Action      bash         $ cd hook_test && pytest -v
Observation 1 failed, 0 passed
Action      patch_file   hook_test/app.py   (Self-Correcting issue)
Action      bash         $ pytest -v
Observation 1 passed
```

--------------------------------

### AURA Core Agent Loop (`aura.agent.run_agent`) Example

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Demonstrates the core Observe → Think → Act → Verify loop using `run_agent`. This function feeds the goal to the LLM, executes tool calls, updates memory, and iterates until the task is complete or `max_iterations` is reached. It automatically retries transient errors.

```python
from aura.memory import Memory
from aura.agent  import run_agent

memory = Memory()                              # fresh session
result = run_agent(
    goal="find all .py files larger than 10 KB in the current directory and list them",
    memory=memory,
    max_iterations=30,                         # safety cap (default)
)
print(result)
# [ AURA ] Found 3 files > 10 KB:
#   • aura/agent.py     (12.1 KB)
#   • aura/tools/desktop.py  (11.3 KB)
#   • aura/tools/forms.py    (10.8 KB)
```

--------------------------------

### Run AURA Verification Tests

Source: https://github.com/abhishek-pandey7/aura---automated-realtime-assistant/blob/main/README.md

Executes the AURA verification suite to validate local configuration and connectivity with the inference server. Ensure all dependencies are installed before running.

```python
# Validates local filesystem, shell, and offline capability functions
python tests/test_tools.py
```

```python
# Validates connectivity and handshakes with the inference server
python tests/test_endpoint.py
```

--------------------------------

### macOS Native Dependencies for Audio Processing

Source: https://github.com/abhishek-pandey7/aura---automated-realtime-assistant/blob/main/README.md

Install portaudio and flac using Homebrew for internal audio processing and voice command functionality. This script also manually assigns the native ARM flac binary to the SpeechRecognition Python package on Apple Silicon.

```bash
# Needed for internal audio processing and /voice commands
brew install portaudio flac
pip install -e .

# Manual Fix: SpeechRecognition on Apple Silicon ships an x86 flac binary by default.
# The following script explicitly assigns the native ARM flac binary to the Python package.
FLAC_DST=".venv/lib/$(python3 -c 'import sys; print(f"python{sys.version_info.major}.{sys.version_info.minor}")')/site-packages/speech_recognition/flac-mac"
cp /opt/homebrew/bin/flac "$FLAC_DST"
```

--------------------------------

### Confirm Shell Command Execution

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Employ `confirm_shell` to get user confirmation before executing a shell command. This is crucial for potentially destructive commands or when AURA is in safe mode.

```python
from aura.confirm import confirm_shell

if confirm_shell("git push origin main"):
    print("User approved the push")
```

--------------------------------

### Learn User Workflow with Imitation Learning

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Record user actions (mouse clicks, keystrokes) for a specified duration to create a reusable `pyautogui` macro. The workflow is saved as a tool and immediately available.

```python
from aura.learning import learn_workflow

# Record up to 60 seconds of user actions (press ESC to stop early)
learn_workflow(
    goal="check my bank balance on HDFC NetBanking",
    duration=60
)
```

--------------------------------

### Run AURA CLI Commands

Source: https://github.com/abhishek-pandey7/aura---automated-realtime-assistant/blob/main/README.md

Initiates the AURA CLI for interactive sessions or single task execution. Use 'aura version' to display the tool's version information.

```bash
aura run
```

```bash
aura run "Target Context"
```

```bash
aura version
```

--------------------------------

### Register and Dispatch Tools

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

The tool registry auto-discovers tools and builds a dispatch table. `ALL_TOOL_DEFS` is passed to the LLM, and `dispatch()` routes tool calls to the corresponding Python functions.

```python
from aura.tools import ALL_TOOL_DEFS, dispatch

# See what tools are registered
print([t["function"]["name"] for t in ALL_TOOL_DEFS])
# ['bash', 'read_file', 'write_file', 'patch_file', 'list_dir', 'delete_file',
#  'web_fetch', 'web_search', 'browser_navigate', 'browser_click', 'browser_fill',
#  'browser_get_text', 'browser_screenshot', 'desktop_click', 'desktop_type', …]

# Call a tool directly (as the agent loop does internally)
result = dispatch("bash", {"command": "echo hello world"})
print(result)   # "hello world"

result = dispatch("web_search", {"query": "Python asyncio tutorial", "max_results": 3})
print(result)   # bullet list of search results
```

--------------------------------

### Capture Voice Input

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Use `capture_voice` to record audio from the microphone, transcribe it using speech-to-text, and return the spoken goal as a string. This is also available as a slash command in the REPL.

```python
from aura.ui import capture_voice

spoken_goal = capture_voice()
# 🎤 VOICE MODE
# Adjusting for background noise...
# Listening... Speak now.
# Transcribing...
# You said: "search for the latest LangChain docs and summarise them"
print(spoken_goal)
```

--------------------------------

### AURA In-Session REPL Controls

Source: https://github.com/abhishek-pandey7/aura---automated-realtime-assistant/blob/main/README.md

Provides a list of commands available within the AURA interactive session for managing context, tools, and learning.

```bash
/voice
```

```bash
/help
```

```bash
/clear
```

```bash
/sessions
```

```bash
/resume
```

```bash
/tools
```

```bash
/learn
```

```bash
/cwd
```

```bash
/exit
```

--------------------------------

### Desktop Automation and OCR

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Provides OS-level control for mouse and keyboard, with OCR capabilities to read screen elements. Use `desktop_read_screen` for spatial maps, `desktop_find_text` to locate elements, and `desktop_click` to interact.

```python
from aura.tools import dispatch

# 1. Get a full spatial map of the screen (Windows OCR / Tesseract fallback)
screen_map = dispatch("desktop_read_screen", {})
print(screen_map)
# [ AURA ] Screen Map (1920x1080) — 47 text regions found:
#    [  X ,   Y ]  Text
#   -------------------------------------------------------
#    [  960,   40]  Google Chrome
#    [  480,  120]  Search Google or type a URL
#    [  960,  320]  Sign in to Chrome
#    …

# 2. Find a specific element and click it
result = dispatch("desktop_find_text", {"text": "Sign in"})
# → "[ AURA ] Matches found:
#   'Sign in to Chrome' at (960, 320)"

dispatch("desktop_click", {"x": 960, "y": 320})

# 3. Type text and press Enter
dispatch("desktop_type", {"text": "user@example.com", "press_enter": True})

# 4. Press hotkey combinations
dispatch("desktop_press", {"keys": ["ctrl", "t"]})   # new tab
dispatch("desktop_press", {"keys": ["win"]})          # open Start menu

# 5. Scroll on the page
dispatch("desktop_scroll", {"x": 960, "y": 540, "clicks": -5})  # scroll down

# 6. Use vision model for complex visual analysis
analysis = dispatch("desktop_analyze_screen", {"reason": "identify the login button"})
# → attaches JPEG screenshot to the next LLM call for visual reasoning
```

--------------------------------

### Google Meet Creation Tool

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Creates Google Meet video conferences linked to Calendar events. Optionally sends invites to attendees and/or an email with the Meet link to specified recipients.

```python
from aura.tools import dispatch

result = dispatch("meet_create", {
    "title": "Sprint Planning — Week 17",
    "start_datetime": "2025-04-21T10:00:00",
    "end_datetime":   "2025-04-21T11:00:00",
    "attendees":      ["alice@example.com", "bob@example.com"],
    "email_link_to":  ["external@partner.com"],
    "description":    "Agenda:\n1. Review sprint backlog\n2. Assign tasks\n3. Set velocity target"
})
print(result)
# [ AURA ] ✓ Google Meet created!
#   Title    : Sprint Planning — Week 17
#   Starts   : 2025-04-21T10:00:00+05:30
#   Meet link: https://meet.google.com/abc-defg-hij
#   Calendar : https://www.google.com/calendar/event?eid=…
#   Invites sent to: alice@example.com, bob@example.com
#   Meet link emailed to: external@partner.com
```

--------------------------------

### Dispatch Learned Workflow Tool

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

After a workflow is learned and registered as a tool, it can be called using the `dispatch` function with the tool's name and any required arguments.

```python
# The new tool is now available in ALL_TOOL_DEFS and callable via dispatch()
from aura.tools import dispatch
dispatch("check_bank_balance", {})
```

--------------------------------

### Google Meet Tool

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Creates a Google Meet video conference, optionally sending invites and an email with the Meet link.

```APIDOC
## Google Meet Tool — `meet_create`

Creates a Google Meet video conference linked to a Calendar event in a single call. Optionally sends calendar invites to attendees and/or a plain-text email with the Meet link to additional recipients.

### `meet_create`

Creates a Google Meet event.

**Parameters**:
- `title` (string) - Required - The title of the Meet event.
- `start_datetime` (string) - Required - The start date and time in ISO 8601 format (e.g., "2025-04-21T10:00:00").
- `end_datetime` (string) - Required - The end date and time in ISO 8601 format (e.g., "2025-04-21T11:00:00").
- `attendees` (array of strings) - Optional - A list of email addresses for attendees to invite.
- `email_link_to` (array of strings) - Optional - A list of email addresses to send the Meet link to.
- `description` (string) - Optional - A description for the Meet event.
```

--------------------------------

### Desktop Vision & Control Tools

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Enables OS-level mouse and keyboard automation with OCR-based spatial perception. It can read the screen, find elements by text, click, type, press keys, scroll, and perform visual analysis.

```APIDOC
## Desktop Vision & Control Tools

Full OS-level mouse/keyboard automation with OCR-based spatial perception. `desktop_read_screen` returns a coordinate-annotated text map of every visible UI element, enabling click-by-location on any application without hardcoded coordinates.

### `desktop_read_screen`

Returns a spatial map of all visible UI elements on the screen.

**Parameters**:
- None

### `desktop_find_text`

Finds UI elements containing the specified text.

**Parameters**:
- `text` (string) - Required - The text to search for on the screen.

### `desktop_click`

Performs a mouse click at the specified coordinates.

**Parameters**:
- `x` (integer) - Required - The X-coordinate to click.
- `y` (integer) - Required - The Y-coordinate to click.

### `desktop_type`

Types the specified text into the active input field. Optionally presses Enter.

**Parameters**:
- `text` (string) - Required - The text to type.
- `press_enter` (boolean) - Optional - Whether to press Enter after typing.

### `desktop_press`

Simulates pressing key combinations.

**Parameters**:
- `keys` (array of strings) - Required - An array of keys to press (e.g., `["ctrl", "t"]`).

### `desktop_scroll`

Performs a scroll action at the specified coordinates.

**Parameters**:
- `x` (integer) - Required - The X-coordinate to scroll from.
- `y` (integer) - Required - The Y-coordinate to scroll from.
- `clicks` (integer) - Required - The number of scroll clicks (positive for up, negative for down).

### `desktop_analyze_screen`

Uses a vision model for complex visual analysis of the screen.

**Parameters**:
- `reason` (string) - Required - The reason for the analysis (e.g., "identify the login button").
```

--------------------------------

### Perform Filesystem Operations

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

A suite of file operations including reading, writing, patching, listing directories, and deleting files. `write_file` and `patch_file` show previews and confirm in safe mode. `patch_file` performs a single-occurrence string replacement.

```python
from aura.tools import dispatch

# Read a file
content = dispatch("read_file", {"path": "aura/config.py"})
print(content[:80])

# Write a new file (creates parent dirs automatically)
dispatch("write_file", {
    "path": "myapp/app.py",
    "content": "from flask import Flask\napp = Flask(__name__)\n\n@app.route('/ping')\ndef ping():\n    return 'pong'\n"
})
# → "[ AURA ] Written: myapp/app.py (91 chars)"

# Surgical patch — replaces first occurrence only
dispatch("patch_file", {
    "path": "myapp/app.py",
    "old_str": "return 'pong'",
    "new_str": "return {'status': 'ok'}"
})
# → "[ AURA ] Patched: myapp/app.py"

# List directory
print(dispatch("list_dir", {"path": "myapp"}))
# 📄  app.py  [112 B]
# 📄  requirements.txt  [23 B]

# Delete with forced confirmation
dispatch("delete_file", {"path": "myapp/old_file.py"})
# ⚠ AURA wants to delete: myapp/old_file.py  →  Proceed? [Y/N]
```

--------------------------------

### Extend AURA with Custom Tools

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Make AURA's capabilities extensible by adding domain-specific tools. Drop any Python file with a `TOOL_DEF` dictionary and a matching function into `aura/tools/` for auto-discovery.

```python
# Example of a custom tool definition:
# TOOL_DEF = {
#     "name": "get_current_time",
#     "description": "Gets the current system time.",
#     "parameters": {},
# }
# 
# def get_current_time():
#     import datetime
#     return datetime.datetime.now().isoformat()
```

--------------------------------

### Save and Load User Profile Data

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Use `dispatch` to update specific fields in the user's local profile or load the entire profile as a string. The loaded profile is a JSON string that can be parsed for use.

```python
dispatch("forms_update_profile", {"field": "full_name",   "value": "Abhishek Pandey"})
dispatch("forms_update_profile", {"field": "email",       "value": "abhishek@example.com"})
dispatch("forms_update_profile", {"field": "college",     "value": "IIT Delhi"})
dispatch("forms_update_profile", {"field": "year_of_study","value": "3rd Year"})
```

```python
profile_str = dispatch("forms_load_profile", {})
print(profile_str[:200])
```

--------------------------------

### Programmatic Single-Goal Execution in AURA

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Executing a single goal programmatically, mirroring the `aura run "<goal>"` CLI command. This involves planning tasks and running the agent.

```python
# Programmatic single-goal execution (mirrors `aura run "<goal>"`)
import os
from aura.memory import Memory
from aura.planner import plan
from aura import agent

memory = Memory()
goal   = "create a directory called myapp with app.py and requirements.txt"
tasks  = plan(goal, os.getcwd())

for task in tasks:
    result = agent.run_agent(task, memory)
    print(result)
# Output:
# [ AURA ] ✓  Created directory myapp/
# [ AURA ] ✓  Written: myapp/app.py (312 chars)
# [ AURA ] ✓  Written: myapp/requirements.txt (45 chars)
```

--------------------------------

### Confirm File Write Operation

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Use `confirm_write` to prompt the user for approval before writing content to a file. This acts as a safety layer, especially in safe mode or for critical operations.

```python
from aura.confirm import confirm_write

if confirm_write("output/report.md", preview="# Report\n\nGenerated by AURA …"):
    print("User approved the write")
```

--------------------------------

### Interact with Web Content

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Tools for web interaction, including searching the web using DuckDuckGo (with Google fallback) and fetching clean page content with BeautifulSoup. Fetched content automatically strips scripts, navbars, and footers.

```python
from aura.tools import dispatch

# Search the web
results = dispatch("web_search", {"query": "FastAPI background tasks tutorial", "max_results": 3})
print(results)
# • FastAPI Background Tasks - Official Docs
#   fastapi.tiangolo.com/tutorial/background-tasks/
#   Run operations after returning a response …
# …

# Fetch and read a specific page
text = dispatch("web_fetch", {
    "url": "https://docs.python.org/3/library/asyncio-task.html",
    "max_chars": 2000
})
print(text[:300])
# Coroutines and Tasks
# Coroutines declared with async/await syntax are the preferred way to write asyncio apps …
```

--------------------------------

### Generate Pre-filled Google Forms URL

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Construct a pre-filled Google Forms URL by providing the form URL and a dictionary of entry IDs mapped to their corresponding values. The `dispatch` function handles the URL generation.

```python
url_result = dispatch("forms_generate_prefill_url", {
    "form_url": "https://docs.google.com/forms/d/1FAIpQLSe.../viewform",
    "field_values": {
        "entry.123456789": "Abhishek Pandey",
        "entry.987654321": "abhishek@example.com",
        "entry.111222333": "IIT Delhi"
    }
})
print(url_result)
```

--------------------------------

### Browser Automation Tools

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Provides Playwright-backed Chrome automation. It can navigate to URLs, extract text, fill forms, click elements, and take screenshots. State is preserved across calls.

```APIDOC
## Browser Automation Tools — `browser_navigate`, `browser_click`, `browser_fill`, `browser_get_text`, `browser_screenshot`

Playwright-backed Chrome automation. Attempts to connect to an existing Chrome remote-debugging session (port 9222), then falls back to launching the user's persistent Chrome profile, then a clean Chromium window. State (cookies, logins) is preserved across tool calls within a session.

### `browser_navigate`

Navigates the browser to a specified URL.

**Parameters**:
- `url` (string) - Required - The URL to navigate to.

### `browser_get_text`

Extracts all visible text from the current browser page.

**Parameters**:
- None

### `browser_fill`

Fills an input element with the provided value using a CSS selector.

**Parameters**:
- `selector` (string) - Required - The CSS selector for the input element.
- `value` (string) - Required - The text to fill into the input element.

### `browser_click`

Clicks an element identified by a CSS selector.

**Parameters**:
- `selector` (string) - Required - The CSS selector for the element to click.

### `browser_screenshot`

Takes a full-page screenshot and saves it to a specified path.

**Parameters**:
- `path` (string) - Required - The file path to save the screenshot to.
```

--------------------------------

### Programmatic Python Integration with AURA

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Integrate AURA's autonomous execution loop into larger Python applications. Pass custom goals and inspect structured session output by importing core components.

```python
from aura.agent import plan, run_agent
from aura.memory import Memory

# Example usage:
# goal = "Write a Python script to fetch the current weather for London."
# memory = Memory()
# session = run_agent(goal, memory)
# print(session.output)
```

--------------------------------

### Manage Conversation History with Memory

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Use the Memory class to manage conversation history in OpenAI message format. Sessions are persisted and can be listed and resumed across restarts. Use `clear()` to reset the current session's context.

```python
from aura.memory import Memory

# --- New session ---
mem = Memory()
print(mem.session_id)          # e.g. "20250419_153012"

mem.add_user("Build a todo app")
mem.add_assistant("Sure, here is the plan …")

# --- Inspect stored sessions ---
for s in Memory.list_sessions():
    print(s["id"], s["started"], s["messages"], "msgs")
# 20250419_153012   2025-04-19T15:30:12   6 msgs
# 20250418_091544   2025-04-18T09:15:44   24 msgs

# --- Resume a previous session ---
mem2 = Memory(session_id="20250418_091544")
print(len(mem2.get_messages()))   # 24

# --- Clear context (e.g. /clear command) ---
mem2.clear()
print(len(mem2.get_messages()))   # 0
```

--------------------------------

### Confirm File Deletion

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Utilize `confirm_delete` to ensure user consent before deleting a file. This function always forces a prompt, regardless of the AURA safe mode setting.

```python
from aura.confirm import confirm_delete

# confirm_delete always forces the prompt (force=True)
if confirm_delete("important_data.db"):
    print("User confirmed deletion")
```

--------------------------------

### Run AURA via CLI

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Embed AURA's autonomous execution into shell scripts or CI pipelines for automated tasks. This method is suitable for build, test, deploy, or notification processes without direct code modification.

```bash
aura run "<goal>"
```

--------------------------------

### Google Forms Tools

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Manages local user profiles for form auto-filling and generates Google Forms pre-fill URLs.

```APIDOC
## Google Forms Tools — `forms_load_profile`, `forms_update_profile`, `forms_generate_prefill_url`

Local user profile management and Google Forms pre-fill URL generation. The profile is stored as `user_profile.json` in the project root and is used by the agent to auto-fill web forms via desktop or browser tools.

### `forms_load_profile`

Loads the user profile from `user_profile.json`.

**Parameters**:
- None

### `forms_update_profile`

Updates the user profile with new data and saves it to `user_profile.json`.

**Parameters**:
- `profile_data` (object) - Required - An object containing the profile data to update.

### `forms_generate_prefill_url`

Generates a pre-filled URL for a Google Form based on the current user profile.

**Parameters**:
- `form_url` (string) - Required - The URL of the Google Form.
```

--------------------------------

### Browser Automation with Playwright

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Automates browser actions like navigation, text extraction, form filling, and screenshotting. It attempts to connect to an existing Chrome remote-debugging session or launches a new profile, preserving state across calls.

```python
from aura.tools import dispatch

# Navigate to a URL
dispatch("browser_navigate", {"url": "https://news.ycombinator.com"})
# → "[ AURA ] Navigated to: https://news.ycombinator.com — title: Hacker News"

# Extract full page text
text = dispatch("browser_get_text", {})
print(text[:500])

# Fill a search input by CSS selector
dispatch("browser_navigate", {"url": "https://github.com"})
dispatch("browser_fill", {"selector": "input[name='q']", "value": "aura autonomous agent"})
dispatch("browser_click", {"selector": "button[type='submit']"})

# Take a full-page screenshot
dispatch("browser_screenshot", {"path": "/tmp/github_results.png"})
# → "[ AURA ] Screenshot saved: /tmp/github_results.png"
```

--------------------------------

### Execute Shell Commands with Bash Tool

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

The bash tool runs shell commands, capturing stdout and stderr. It prompts for confirmation on destructive commands in safe mode (`AURA_SAFE_MODE=true`).

```python
from aura.tools import dispatch

# Basic command
out = dispatch("bash", {"command": "ls -lh aura/"})
print(out)

# With custom timeout (seconds)
out = dispatch("bash", {"command": "pytest tests/ -v", "timeout": 120})
print(out)
# ==================== 5 passed in 0.43s ====================

# Dangerous command — user will be prompted Y/N in safe mode
out = dispatch("bash", {"command": "rm -rf ./build"})
# ◆ AURA wants to run a shell command:  $ rm -rf ./build
# Proceed? [Y/N] › N
# → "[ AURA ] Command cancelled by user."
```

--------------------------------

### Gmail Tools

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Allows sending and reading emails via the Gmail API using OAuth2. Requires `credentials.json` with Gmail and Calendar APIs enabled.

```APIDOC
## Gmail Tools — `gmail_send`, `gmail_read_inbox`

Send and read email via Gmail API with OAuth2 (no SMTP, no browser). Requires `credentials.json` from Google Cloud Console with Gmail + Calendar APIs enabled.

### `gmail_send`

Sends an email.

**Parameters**:
- `to` (string) - Required - The recipient's email address.
- `subject` (string) - Required - The email subject.
- `body` (string) - Required - The email body content.
- `cc` (string) - Optional - The CC recipient's email address.

### `gmail_read_inbox`

Reads the latest unread emails from the inbox.

**Parameters**:
- `max_results` (integer) - Optional - The maximum number of emails to retrieve.
```

--------------------------------

### Google Forms Profile Management

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Manages local user profiles for Google Forms auto-filling and generates pre-fillable URLs. The profile is stored in `user_profile.json` and used by desktop or browser tools.

```python
from aura.tools import dispatch
```

--------------------------------

### Gmail API for Sending and Reading Emails

Source: https://context7.com/abhishek-pandey7/aura---automated-realtime-assistant/llms.txt

Manages email operations via the Gmail API, supporting sending emails with recipients, subjects, and bodies, as well as reading unread inbox messages. Requires OAuth2 credentials.

```python
from aura.tools import dispatch

# Send an email
result = dispatch("gmail_send", {
    "to": "colleague@example.com",
    "subject": "AURA Test Results",
    "body": "Hi,\n\nAll 12 pytest tests passed on the latest build.\n\n— AURA",
    "cc": "manager@example.com"
})
print(result)
# → "[ AURA ] ✓ Email sent to colleague@example.com with subject 'AURA Test Results'."

# Read latest unread inbox messages
inbox = dispatch("gmail_read_inbox", {"max_results": 3})
print(inbox)
# [ AURA ] 3 unread email(s):
#   • From: alice@example.com
#     Subject: Re: Project Update
#     Date: Mon, 19 Apr 2025 10:32:00 +0530
#     Preview: Sounds great, I'll review the PR by EOD …
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.