edith-pc 0.3.0__tar.gz

edith_pc-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shuvo
+
+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.

edith_pc-0.3.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: edith-pc
+Version: 0.3.0
+Summary: EDITH on this PC: a body of your EDITH server, linked with a Google Authenticator code
+Author: Shuvo
+License-Expression: MIT
+Keywords: assistant,voice assistant,automation,windows,openai
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Topic :: Desktop Environment
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.70.0
+Requires-Dist: websockets>=15.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: requests>=2.31
+Requires-Dist: psutil>=5.9
+Requires-Dist: APScheduler<4.0,>=3.10
+Requires-Dist: SQLAlchemy>=2.0
+Requires-Dist: pycaw>=20240210; sys_platform == "win32"
+Requires-Dist: comtypes>=1.2; sys_platform == "win32"
+Requires-Dist: pynput>=1.7
+Requires-Dist: screen-brightness-control>=0.22
+Requires-Dist: pyautogui>=0.9.54
+Requires-Dist: pyperclip>=1.8
+Requires-Dist: AppOpener>=1.7; sys_platform == "win32"
+Requires-Dist: mss>=9.0
+Requires-Dist: windows-toasts>=1.1; sys_platform == "win32"
+Requires-Dist: pypdf>=4.0
+Requires-Dist: Pillow>=10
+Requires-Dist: customtkinter>=5.2
+Dynamic: license-file
+
+# EDITH for your PC
+
+`edith-pc` makes a Windows PC a body of your **EDITH** server: the server's brain can use this
+PC's tools (apps, windows, files, the screen, the keyboard, the shell) when you talk to EDITH
+from your phone or the browser, from anywhere.
+
+You need an EDITH server (the brain) with Google Authenticator sign-in set up. This package is
+only the PC side.
+
+## Install and link
+
+```
+pip install edith-pc
+edith link
+```
+
+`edith link` asks for your server's address and the 6-digit code Google Authenticator shows
+for EDITH. That's all: no token or key to copy. The PC is linked, EDITH runs in the
+background, and it starts with Windows from then on.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `edith status` | what this PC is linked to, and whether EDITH is running |
+| `edith start` / `edith stop` | start or stop the background body |
+| `edith app` | open the EDITH window |
+| `edith run` | run the body in the terminal (Ctrl+C stops it) |
+| `edith update` | install the newest version and restart |
+| `edith unlink` | unlink this PC and stop starting with Windows |
+
+## What the PC can and can't do
+
+The server gives this PC a key of its own when you link it. The key only lets the PC answer
+the brain's tool calls and send model calls through your server, so no OpenAI key lives on
+the PC. It can't send commands, approve actions or read the server's files. Remove the PC in
+EDITH's HUD (Bodies, PCs) and its key stops working at once.
+
+Windows only. Python 3.10 or newer.

edith_pc-0.3.0/PYPI.md

@@ -0,0 +1,39 @@
+# EDITH for your PC
+
+`edith-pc` makes a Windows PC a body of your **EDITH** server: the server's brain can use this
+PC's tools (apps, windows, files, the screen, the keyboard, the shell) when you talk to EDITH
+from your phone or the browser, from anywhere.
+
+You need an EDITH server (the brain) with Google Authenticator sign-in set up. This package is
+only the PC side.
+
+## Install and link
+
+```
+pip install edith-pc
+edith link
+```
+
+`edith link` asks for your server's address and the 6-digit code Google Authenticator shows
+for EDITH. That's all: no token or key to copy. The PC is linked, EDITH runs in the
+background, and it starts with Windows from then on.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `edith status` | what this PC is linked to, and whether EDITH is running |
+| `edith start` / `edith stop` | start or stop the background body |
+| `edith app` | open the EDITH window |
+| `edith run` | run the body in the terminal (Ctrl+C stops it) |
+| `edith update` | install the newest version and restart |
+| `edith unlink` | unlink this PC and stop starting with Windows |
+
+## What the PC can and can't do
+
+The server gives this PC a key of its own when you link it. The key only lets the PC answer
+the brain's tool calls and send model calls through your server, so no OpenAI key lives on
+the PC. It can't send commands, approve actions or read the server's files. Remove the PC in
+EDITH's HUD (Bodies, PCs) and its key stops working at once.
+
+Windows only. Python 3.10 or newer.

edith_pc-0.3.0/README.md

@@ -0,0 +1,262 @@
+# 🤖 EDITH — a real-time desktop voice assistant
+
+> Talk to your computer like Tony Stark. A Python desktop assistant built on the **OpenAI Realtime API** (`gpt-realtime-2.1-mini` by default, `gpt-realtime-2.1` for demos) — a sleek, tactical AI that wakes to a hotword, holds a natural, continuous spoken conversation, and actually **does things**: delegates hard questions to a stronger reasoning model, autonomously drives your mouse and keyboard through multi-step tasks, plays Spotify, reads your email and documents aloud, runs your smart home, and controls your PC.
+
+<!-- TODO: record a 30–60s demo and drop it here. A GIF (<10MB) renders inline on GitHub and beats a YouTube link. -->
+<!-- ![EDITH demo](docs/demo.gif) -->
+
+[![CI](https://github.com/sohanurislamshuvo/edith/actions/workflows/ci.yml/badge.svg)](https://github.com/sohanurislamshuvo/edith/actions/workflows/ci.yml)
+![Python](https://img.shields.io/badge/python-3.10+-blue)
+![Platform](https://img.shields.io/badge/platform-Windows-0078D6)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+---
+
+## ✨ Features
+
+- 🎙️ **Speech-to-speech, real time** — OpenAI Realtime API over WebSocket, sub-second responses. **Barge-in** (interrupt it mid-sentence and it stops to listen) works with headphones; on laptop speakers it runs half-duplex by default so it can't hear itself (`EDITH_HALF_DUPLEX`).
+- 🗣️ **Wake word + continuous conversation** — keyless, fully on-device hotword (default **"Edith"**) via Vosk — `pip install vosk` then `python scripts/setup_wake_word.py`, no account or cost (see [docs/WAKE_WORD.md](docs/WAKE_WORD.md)); after each reply she keeps listening, so follow-ups need no wake word until it idle-sleeps (`EDITH_IDLE_TIMEOUT_SECONDS`). Without setup she falls back to a Press-Enter prompt.
+- 🧠 **Hybrid brain** — the voice model handles the conversation; genuinely hard questions (research, math, debugging, planning) are **delegated to a stronger reasoning model with live web access** and the answer is spoken back (`delegate_task`).
+- 🖱️ **Computer autonomy** — *"Open Notepad and write a shopping list"* actually happens: a bounded **see → decide → act → verify** loop screenshots the screen, plans one action at a time, and drives the mouse/keyboard — confirm-gated, cost-capped, audited, with ESC and mouse-corner kill switches.
+- 🧰 **70 function-calling tools** — it doesn't just talk, it acts:
+  - 🌐 Live **web search**, 📰 **news headlines**, 📈 **stock quotes**, 💱 **currency conversion** (all keyless)
+  - 🌦️ **Weather** (Open-Meteo, no API key) & 🕐 time/date
+  - ⏰ **Reminders & timers** (persistent, SQLite) with desktop notifications, plus a spoken **morning briefing** on the day's first wake
+  - 🧠 **Semantic long-term memory** — "remember my wifi password"; recall works by meaning, not exact words
+  - 👁️ **Screen vision & diagnosis** — *"What's wrong on my screen?"*; EDITH captures the screen, **analyzes** it, and reads out a **step-by-step fix plan** (then it can act with the mouse/keyboard).
+  - 🎵 **Spotify** play-by-name + now-playing, 🎬 YouTube
+  - 📧 **Gmail & Google Calendar** — unread summaries, send (confirm-gated), list/create events
+  - 🏠 **Home Assistant** — lights/switches/scenes by their spoken names
+  - 📄 **Document reading** — *"summarize the PDF on my desktop"* (PDF/txt/md/code)
+  - 📱 **Telegram push-to-phone** and **WhatsApp** (message prefilled, you press send)
+  - 📝 **Voice notes** — dictate to per-topic Markdown files and read them back
+  - 💻 **PC control**: open/close apps, system stats, volume, **screen brightness**, media keys, screenshots, **type & hotkeys & mouse**, **files/folders & clipboard**, **window & power** (lock/sleep/shutdown), and **shell commands** — with spoken confirmation required for anything destructive, plus an ambient **health watchdog** (battery/disk/CPU toasts).
+- 💸 **Cost-guarded by design** — split-prefix prompt caching, trimmed tool outputs, a live token/$ budget counter that also meters every delegated model call, idle-close, and a hard auto-disconnect timer so a forgotten session can't drain your credit.
+- 🖥️ **Desktop HUD ("Halo Reactor")** — a frameless, glass-panelled interface built around a real Gaussian-bloomed arc-reactor orb that breathes, pulses with your voice and crossfades colour by state, with a holographic ring assembly, speech ripples, a live transcript, a status readout and a running cost meter (`python -m edith.gui`).
+
+## 🏗️ Architecture
+
+```mermaid
+flowchart LR
+    A[🎤 Mic] -->|PCM16 24kHz| B[audio_io]
+    W[👂 Wake word<br/>'Edith'] -->|gate| C
+    B -->|base64 frames| C[realtime_client<br/>WebSocket]
+    C <-->|speech-to-speech| D[(OpenAI Realtime API)]
+    D -->|function_call| E[tools/registry]
+    E --> F[web · weather · news · stocks · reminders<br/>delegate_task · computer agent · memory<br/>Spotify · Gmail/Calendar · Home Assistant<br/>screen vision · documents · pc_control]
+    F -->|trimmed JSON| C
+    D -->|audio deltas| B
+    B -->|cedar voice| G[🔊 Speaker]
+    C -.usage.-> H[session_manager<br/>budget guard + hard timer]
+```
+
+**Why it's structured this way:** the transport (`realtime_client`), audio (`audio_io`), tools (`tools/`), and cost guardrails (`session_manager`) are decoupled, so any layer — model, voice, or a new tool — can be swapped without touching the others.
+
+## 🚀 Quickstart
+
+```powershell
+# 1. Clone & enter
+git clone <your-repo-url> edith ; cd edith
+
+# 2. Create a virtual env and install
+python -m venv .venv ; .\.venv\Scripts\Activate.ps1
+pip install -r requirements.txt
+pip install -r requirements-dev.txt   # optional: pytest — then `python -m pytest`
+
+# 3. Add your keys
+Copy-Item .env.example .env      # then edit .env: add your OPENAI_API_KEY
+
+# 4. Sanity-check your mic & speakers (records 3s, plays it back)
+python scripts/test_audio.py
+
+# 5. Verify the tools work with ZERO API cost (no voice yet)
+python scripts/test_tools_text.py
+
+# 6. Talk to EDITH — pick one:
+python -m edith.gui          # Halo Reactor HUD: bloom orb + glass transcript + cost meter
+python -m edith.gui_classic  # the original HUD (guaranteed-working fallback)
+python -m edith.main         # terminal / CLI
+```
+
+Say **"Edith"** (the default hotword, keyless via Vosk — run `python scripts/setup_wake_word.py` once to enable it), wait for the greeting, then try: *"What's my CPU and battery?"*, *"Play Bohemian Rhapsody."*, *"What's Apple stock at?"*, *"What's 100 dollars in taka?"*, *"Research the best budget mechanical keyboards for me."* (delegates to the reasoning model), or *"Open Notepad and write a shopping list."* (autonomous computer task — confirm it, hands off, ESC aborts). Follow-ups need no wake word; it goes back to sleep after ~30s of silence.
+
+**Optional integrations** (each degrades gracefully when unconfigured — see `.env.example`): Spotify (2-minute free dev app), Telegram (BotFather token), Home Assistant (long-lived token), Gmail/Calendar (`python scripts/setup_google.py` after a one-time Google Cloud setup; Testing-mode tokens re-consent weekly).
+
+## 📱 Phone app (Android)
+
+EDITH's second body. The Android app in [`android/`](android/) connects to the PC over Wi-Fi,
+Tailscale or your own relay, and both directions work: control the PC from your phone, and let EDITH control the
+phone — 47 tools in 11 access groups you can switch off one by one: apps, notifications
+(WhatsApp/Telegram/Messenger/Gmail), the SMS inbox and call log, calls, contacts, calendar,
+weather, location, media playback, brightness, ringer, torch, DND, files (both ways between
+phone and PC), Home Assistant, and **any app's screen** through the accessibility service
+(`phone_drive_screen`). She can **look** through the camera or at the screen, remembers facts
+(synced with the PC's memory), runs your **routines**, delivers a **morning briefing** and
+keeps an **activity log** of everything she does on the phone. Confirm-gated actions show up as
+**Yes / No** cards. The app has its own brain (your OpenAI key, encrypted on the phone), so chat,
+**Live** voice (Realtime API), the **"Edith" wake word** (on-device Vosk, like the PC), the
+Quick Settings tile, widget and assistant gesture, phone tasks and **auto-reply** keep working
+with the PC off; linking the PC adds its tools and its budget. Share anything to EDITH from any
+app's share sheet. The app is a port of the desktop Halo Reactor HUD:
+
+<p align="center">
+<img src="docs/phone-hud-idle.png" width="220" alt="EDITH phone HUD standing by">
+<img src="docs/phone-hud-working.png" width="220" alt="EDITH phone HUD working">
+<img src="docs/phone-hud-approval.png" width="220" alt="EDITH phone HUD approval card">
+</p>
+
+```powershell
+pip install -r requirements.txt       # adds fastapi + uvicorn
+python -m edith.service               # prints the address + pairing token for the app
+```
+
+To have it running whenever the PC is on, register it once as a hidden logon task that
+restarts itself after a crash (its output then goes to `~/.edith.log`; the token is in
+`~/.edith_service_token`):
+
+```powershell
+powershell -ExecutionPolicy Bypass -File scripts\install_autostart.ps1 -Start   # -Status / -Uninstall
+```
+
+Then build/install the app (see [android/README.md](android/README.md)), enter the address
+and token, tap Connect. Never port-forward the service. From outside your Wi-Fi, either run
+your own relay, a small server both ends connect out to, end-to-end encrypted with the
+pairing token ([docs/RELAY.md](docs/RELAY.md)), or use Tailscale
+([android/README.md → Reach the PC from anywhere](android/README.md#reach-the-pc-from-anywhere-tailscale)).
+Design notes: [docs/MOBILE.md](docs/MOBILE.md).
+
+**Or run the brain on your own server** ([docs/SERVER.md](docs/SERVER.md)): `python -m edith.service` with
+`EDITH_ROLE=server` on a small Linux VPS behind Caddy gives you EDITH at your own domain, a browser HUD (sign in with Google Authenticator),
+the phone working with the PC off, and the OpenAI key living only on the server. The PC links to it as a
+body (`python -m edith.body`), so its tools work from anywhere while it is on. Any other PC needs no code at
+all: install **EDITH for Windows** (`EDITH-Setup.exe` from a `pc-v*` release), or with Python
+`pip install edith-pc`, and link it with a six-digit code from
+Google Authenticator (`edith link`).
+
+## ⚙️ Configuration
+
+All config lives in `.env` (see `.env.example`):
+
+| Key | Default | What it does |
+|---|---|---|
+| `OPENAI_API_KEY` | — | **Required.** OpenAI key. |
+| `PICOVOICE_ACCESS_KEY` | — | Optional legacy wake-word engine (Vosk is the keyless default; Picovoice now needs a paid plan). |
+| `EDITH_MODEL` | `gpt-realtime-2.1-mini` | `gpt-realtime-2.1` (best) / `gpt-realtime-2.1-mini` (cheap, for dev). The older `gpt-realtime-mini` shuts down 2027-01-20. |
+| `EDITH_VOICE` | `marin` | Spoken voice (EDITH default; `cedar` for the old deep voice). |
+| `EDITH_SESSION_MAX_SECONDS` | `300` | Hard auto-disconnect per session. |
+| `EDITH_IDLE_TIMEOUT_SECONDS` | `30` | Continuous conversation: seconds of silence before going back to sleep (0 = off). |
+| `EDITH_DAILY_BUDGET_USD` | `2.0` | Hard stop once a day's spend crosses this (includes delegated model calls). |
+| `EDITH_HALF_DUPLEX` | `true` | Mutes the mic while EDITH speaks (stops it hearing itself on laptop speakers). Set `false` + use headphones for true barge-in. |
+| `EDITH_DELEGATE_MODEL` | `gpt-6-sol` | The reasoning model behind `delegate_task` (`gpt-6-luna` is ~20x cheaper, `gpt-6-astra` the flagship). |
+| `EDITH_VISION_MODEL` / `EDITH_DOC_MODEL` / `EDITH_SEARCH_MODEL` | `gpt-6-luna` | The cheap vision/text model behind `see_screen`, `read_document` and `web_search`. |
+| `EDITH_AGENT_*` | see `.env.example` | Computer-autonomy model, step/time/cost caps, monitor. |
+| `EDITH_BRIEFING*` | see `.env.example` | Morning briefing (on/off, city, news, nudge time). |
+| `EDITH_SERVICE_*` / `EDITH_PHONE_DENYLIST` / `EDITH_INBOX_DIR` | see `.env.example` | Phone link: host/port/pairing token, extra protected phone apps, where phone uploads land (default `~/Downloads/EDITH`). |
+| `EDITH_RELAY_URL` | — | Your own relay, e.g. `wss://relay.example.com/?key=…`: the phone reaches the PC from anywhere ([docs/RELAY.md](docs/RELAY.md)). |
+| Integration keys | see `.env.example` | Spotify, Telegram, Home Assistant, Google, WhatsApp, health watch. |
+
+### 🖥️ Desktop HUD options
+
+The redesigned HUD (`python -m edith.gui`) is **frameless** by default (custom title bar, drag-to-move) and auto-scales to fit your screen. Tweak it with env vars:
+
+| Env var | Default | What it does |
+|---|---|---|
+| `EDITH_NATIVE_FRAME` | `0` | Set `1` to keep the standard OS window (title bar, snap, minimize) instead of the frameless HUD. |
+| `EDITH_TOPMOST` | `0` | Set `1` to float the HUD above other windows (desktop-widget mode). |
+
+- **Fonts:** the wordmark/labels use bundled **Orbitron** + **Rajdhani** (SIL OFL, in `assets/fonts/`), registered at runtime — no system install needed. If they're missing, the HUD falls back to **Bahnschrift** / **Consolas** and still looks intentional.
+- **Escape hatch:** if the new HUD ever misbehaves on a machine, `python -m edith.gui_classic` runs the original UI (same brain, identical behaviour).
+
+## 💸 Cost notes ($70 of credit goes a long way)
+
+Realtime is billed by **audio tokens**, not flat per-minute. With prompt caching + trimmed tool outputs, expect **~$0.05–0.10/min → roughly 12–23 hours** of live conversation on $70. The built-in guardrails (`session_manager.py`) keep you there:
+
+- The **system prompt + tool schemas are byte-stable** → prompt cache hits cut audio-input cost ~80%.
+- Tool results are **trimmed** to only what the model needs before being sent back.
+- A **live budget counter** reads each response's usage and hard-stops at `EDITH_DAILY_BUDGET_USD`.
+- A **hard session timer** force-closes the socket (OpenAI does *not* auto-kill sessions).
+- Develop against `gpt-realtime-2.1-mini`; switch to `gpt-realtime-2.1` only to record demos.
+- Every model a tool can call has a row in `pricing.py`; an unknown id is metered at a mid-priced fallback.
+
+> 🛡️ Backstop: also set a hard monthly spend limit in your OpenAI billing dashboard.
+
+## 📁 Project layout
+
+```
+edith/
+  main.py            entry: wake-word loop -> realtime session
+  config.py          loads .env
+  legacy_migration.py one-time rename of pre-rebrand ~/.jarvis_* state files
+  prompts.py         STABLE EDITH personality (kept byte-identical for caching)
+  pricing.py         per-model token prices for the budget counter
+  realtime_client.py WebSocket transport, event loop, function-call dispatch
+  audio_io.py        mic in / speaker out, barge-in flush, RMS for the orb
+  wake_word.py       Vosk "Edith" listener (legacy Porcupine fallback)
+  session_manager.py hard timer + live token/$ budget guard
+  gui.py             desktop HUD ("Halo Reactor"): bloom orb + glass UI + transcript + cost
+  gui_classic.py     original HUD, kept as a guaranteed-working fallback
+  hud/               HUD render helpers: easing, PIL orb_renderer, textures, font loader
+  tools/
+    registry.py       tool JSON schemas (cached prefix) + name->function dispatch
+    clock.py          current time / date
+    weather.py        Open-Meteo current conditions
+    web_search.py     OpenAI web_search tool + DuckDuckGo fallback
+    delegate.py       delegate_task: hard questions -> stronger reasoning model
+    computer_agent.py execute_computer_task: see->act->verify autonomy loop
+    memory.py         semantic long-term memory (embeddings + cosine recall)
+    briefing.py       morning briefing (weather + reminders + headlines)
+    news_finance.py   news / stock quotes / currency (keyless APIs)
+    spotify_music.py  play-by-name + now-playing
+    google_workspace.py Gmail + Calendar (one-time OAuth via scripts/setup_google.py)
+    home_assistant.py lights/switches/scenes by spoken name
+    documents.py      read/summarize PDFs & text files aloud
+    notes.py          dictated voice notes (per-topic Markdown)
+    telegram_notify.py push text to the user's phone
+    whatsapp.py       prefilled WhatsApp messages (human presses send)
+    health_watch.py   ambient battery/disk/CPU toasts
+    external_cost.py  meters tool API spend into the session budget
+    reminders.py      APScheduler reminders/timers + desktop notifications
+    system_control.py apps, volume, brightness, media keys, screenshots, YouTube
+    vision.py         see_screen: capture + analyze + diagnose
+    pc_control.py     keyboard/mouse, files/clipboard, windows, power, shell
+    window_control.py list/focus/minimize/maximize/close/snap windows by name
+    file_ops.py       list, copy/move/rename, Recycle-Bin delete, zip/unzip
+    task_manager.py   heaviest processes, kill by name (protected list)
+    system_toggles.py mic mute, monitors off, dark mode, recycle bin, network, wallpaper
+    llm.py            shared Responses-API call helper (explicit reasoning effort)
+  service/            phone-app link (python -m edith.service): FastAPI + WebSocket,
+                      text brain over ALL tools, approvals, phone_drive_screen agent
+.github/workflows/    CI (tests on Windows + Linux, Android unit tests + debug APK), deploy of the
+                      server brain on every green master, signed APK on every v* tag (docs/SERVER.md)
+  relay/              reach the PC from anywhere: the relay server (python -m edith.relay),
+                      end-to-end encryption keyed by the pairing token, the PC-side bridge
+  web/static/         the browser HUD served by edith.service at / (chat, bodies, activity, approvals)
+android/              the Android app (Kotlin): 47 phone tools, its own brain (works with the PC off),
+                      live voice, wake word, accessibility agent, vision, auto-reply, PC link
+scripts/             test_audio.py, test_tools_text.py, setup_google.py, install_autostart.ps1
+```
+
+## 🗺️ Roadmap
+
+- [x] Persistent reminders across restarts (SQLite jobstore)
+- [x] Conversation memory / long-term notes (semantic memory + voice notes)
+- [x] Smart-home (Home Assistant) tool
+- [x] Hybrid reasoning (delegate to a stronger model)
+- [x] Autonomous computer use (see → act → verify)
+- [ ] Cross-platform (macOS/Linux) PC-control backends
+- [ ] Telegram remote-control bridge (text commands to EDITH from your phone)
+- [x] Android app v0.1: full phone control + PC remote, one brain two bodies ([android/](android/), [docs/MOBILE.md](docs/MOBILE.md))
+- [x] Android app v0.2: phone-local brain (API key on the phone), auto-reply through notifications, hands-free follow-ups ([android/README.md](android/README.md#works-with-the-pc-off))
+- [x] Android app v0.3: live voice (Realtime API), "Edith" wake word, tile / widget / assistant / headset entry points, camera and screen vision, SMS inbox and call log, media and device controls, Home Assistant, memory sync, routines, morning briefing, share sheet, file transfer, access switches and an activity log ([android/README.md](android/README.md#what-edith-can-do-on-the-phone))
+- [x] Android app v0.4: reach the PC from anywhere through your own end-to-end-encrypted relay ([docs/RELAY.md](docs/RELAY.md))
+- [x] Brain on your own server with a browser HUD and Google Authenticator sign-in; the PC links to it as a body, so the phone reaches PC tools from anywhere, with real approvals ([docs/SERVER.md](docs/SERVER.md))
+- [ ] Sync of notes, reminders and routines across server, PC and phone; optional fallback key per body
+- [ ] Phone app: GPT-Live / WebRTC transport, on-phone document reading
+
+## 📝 License
+
+MIT — see [LICENSE](LICENSE).
+
+---
+
+*Built with the OpenAI Realtime API. Not affiliated with Marvel.* 🦾

edith_pc-0.3.0/edith/__init__.py

@@ -0,0 +1,13 @@
+"""EDITH — a real-time desktop voice assistant built on the OpenAI Realtime API."""
+
+import sys as _sys
+
+# EDITH prints emoji/box-drawing status lines. On Windows those crash with
+# UnicodeEncodeError when stdout is a non-UTF-8 pipe; force UTF-8 with replacement.
+for _stream in (_sys.stdout, _sys.stderr):
+    try:
+        _stream.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+__version__ = "0.3.0"

edith_pc-0.3.0/edith/audio_io.py

@@ -0,0 +1,130 @@
+"""Microphone capture and speaker playback for the Realtime stream.
+
+Design notes:
+- The Realtime API speaks PCM16 / 24 kHz / mono. We capture and play in exactly
+  that format so there is no resampling.
+- Capture runs in a sounddevice callback (a separate thread); we hand frames to the
+  asyncio loop via ``call_soon_threadsafe`` so the event loop is never blocked.
+- Playback uses a callback that drains an internal byte buffer. ``flush_playback()``
+  clears that buffer instantly — this is how barge-in works: when the user starts
+  talking, we drop whatever EDITH was about to say.
+- ``input_level`` / ``output_level`` (0..1 RMS) drive the GUI orb.
+"""
+from __future__ import annotations
+
+import asyncio
+import threading
+
+import numpy as np
+import sounddevice as sd
+
+from .config import BLOCK_FRAMES, CHANNELS, SAMPLE_RATE, SAMPLE_WIDTH
+
+
+def _rms(pcm: bytes) -> float:
+    samples = np.frombuffer(pcm, dtype=np.int16)
+    if samples.size == 0:
+        return 0.0
+    return float(np.sqrt(np.mean((samples.astype(np.float32) / 32768.0) ** 2)))
+
+
+def _rms_arr(samples: np.ndarray) -> float:
+    if samples.size == 0:
+        return 0.0
+    return float(np.sqrt(np.mean((samples.astype(np.float32) / 32768.0) ** 2)))
+
+
+class AudioIO:
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+        self._loop = loop
+        self.mic_queue: asyncio.Queue[bytes] = asyncio.Queue()
+        self._in_stream: sd.RawInputStream | None = None
+        self._out_stream: sd.RawOutputStream | None = None
+        self._play_buf = bytearray()
+        self._play_lock = threading.Lock()
+        self.muted = False
+        self.input_level = 0.0
+        self.output_level = 0.0
+        # latest int16 frames, kept for the GUI's live spectrum (read-only from GUI thread)
+        self._last_in: np.ndarray | None = None
+        self._last_out: np.ndarray | None = None
+
+    # --- microphone (input) ---------------------------------------------------
+    def _on_mic(self, indata, frames, time_info, status) -> None:  # noqa: ANN001
+        data = bytes(indata)
+        samples = np.frombuffer(data, dtype=np.int16)
+        self._last_in = samples
+        self.input_level = _rms_arr(samples)
+        if self.muted:
+            return
+        try:
+            self._loop.call_soon_threadsafe(self.mic_queue.put_nowait, data)
+        except RuntimeError:
+            pass  # event loop already closed
+
+    # --- speaker (output) -----------------------------------------------------
+    def _on_play(self, outdata, frames, time_info, status) -> None:  # noqa: ANN001
+        needed = frames * CHANNELS * SAMPLE_WIDTH
+        with self._play_lock:
+            chunk = bytes(self._play_buf[:needed])
+            del self._play_buf[:needed]
+        if len(chunk) < needed:  # underrun -> pad with silence
+            chunk += b"\x00" * (needed - len(chunk))
+        samples = np.frombuffer(chunk, dtype=np.int16)
+        self._last_out = samples
+        self.output_level = _rms_arr(samples)
+        outdata[:] = chunk
+
+    # --- live spectrum (for the GUI HUD) --------------------------------------
+    def latest_spectrum(self, bands: int = 24) -> np.ndarray:
+        """Peak-normalized voice-band FFT magnitudes (0..1) of the most active stream."""
+        src = self._last_out if self.output_level >= self.input_level else self._last_in
+        if src is None or src.size == 0:
+            return np.zeros(bands, dtype=np.float32)
+        x = src.astype(np.float32) / 32768.0
+        windowed = x * np.hanning(x.size)
+        mag = np.abs(np.fft.rfft(windowed))
+        usable = mag[: max(1, mag.size // 2)]  # lower half ~ voice energy
+        if usable.size < bands:
+            usable = np.pad(usable, (0, bands - usable.size))
+        grouped = np.array([float(g.mean()) for g in np.array_split(usable, bands)], dtype=np.float32)
+        peak = grouped.max()
+        return grouped / peak if peak > 0 else grouped
+
+    def play(self, pcm: bytes) -> None:
+        """Queue assistant audio for playback."""
+        with self._play_lock:
+            self._play_buf.extend(pcm)
+
+    def flush_playback(self) -> None:
+        """Drop all pending playback — called on barge-in to interrupt EDITH."""
+        with self._play_lock:
+            self._play_buf.clear()
+        self.output_level = 0.0
+
+    def is_speaking(self) -> bool:
+        with self._play_lock:
+            return len(self._play_buf) > 0
+
+    # --- lifecycle ------------------------------------------------------------
+    def start(self) -> None:
+        self._out_stream = sd.RawOutputStream(
+            samplerate=SAMPLE_RATE, channels=CHANNELS, dtype="int16",
+            blocksize=BLOCK_FRAMES, callback=self._on_play,
+        )
+        self._in_stream = sd.RawInputStream(
+            samplerate=SAMPLE_RATE, channels=CHANNELS, dtype="int16",
+            blocksize=BLOCK_FRAMES, callback=self._on_mic,
+        )
+        self._out_stream.start()
+        self._in_stream.start()
+
+    def stop(self) -> None:
+        for stream in (self._in_stream, self._out_stream):
+            if stream is not None:
+                try:
+                    stream.stop()
+                    stream.close()
+                except Exception:
+                    pass
+        self._in_stream = self._out_stream = None