alia-ai 1.1.0__tar.gz

alia_ai-1.1.0/.github/workflows/release.yaml

@@ -0,0 +1,35 @@
+name: Release Pipeline
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with: { python-version: "3.13" }
+      - name: Install uv
+        run: curl -LsSf https://astral.sh/uv/install.sh | sh
+      - name: Install dependencies
+        run: uv sync --all-extras --all-groups --no-editable --prerelease allow
+      - name: Run tests
+        run: uv run pytest -q
+
+  publish-pypi:
+    needs: test
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write   # OIDC — Trusted Publishing, no token
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with: { python-version: "3.13" }
+      - name: Install uv
+        run: curl -LsSf https://astral.sh/uv/install.sh | sh
+      - name: Build package
+        run: uv build
+      - name: Publish to PyPI
+        run: uv publish

alia_ai-1.1.0/.github/workflows/tests.yaml

@@ -0,0 +1,21 @@
+name: Run Tests
+
+on:
+  push: { branches: [main] }
+  pull_request: { branches: [main] }
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with: { python-version: "3.13" }
+      - name: Install uv
+        run: curl -LsSf https://astral.sh/uv/install.sh | sh
+      # GTK is not needed for the unit tests (agent core + policy); they never
+      # import alia.hud / alia.app's GTK paths.
+      - name: Install dependencies
+        run: uv sync --all-extras --all-groups --no-editable --prerelease allow
+      - name: Run tests
+        run: uv run pytest -q

alia_ai-1.1.0/.gitignore

@@ -0,0 +1,8 @@
+.venv/
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.env
+.pytest_cache/

alia_ai-1.1.0/AGENTS.md

@@ -0,0 +1,85 @@
+# AGENTS.md — alia
+
+You're an AI agent picking up **alia**. This file is the door.
+
+## What it is
+
+**ALIA** — the cognitive partner of the AI-n-Box desktop: a native GNOME agent
+surface (HUD summoned by a key) on top of the `lingo` engine. Standalone product
+(`syalia-srl/alia`), dev/tested on GNOME, later baked into the `ainbox-os`
+`desktop` variant. ALIA is the *persona/product*; `lovelaice`/`lingo` is the
+*engine*. She is **not** part of the AInBox app suite and does **not** talk to
+superbot/magpie — her store is `$HOME`.
+
+Vision doc (canonical):
+`vault/Atlas/Architecture/2026-06-25-alia-cognitive-partner-vision.md`.
+
+## Conventions
+
+- **Ships directly to `main`** — no PR cycle (same as the other SYALIA repos).
+- **Vertical-slice-first.** Build the thinnest end-to-end path, then widen.
+- Agent core is unit-tested (lingo `MockLLM`, offline); the GTK HUD is
+  smoke-tested by hand. Keep tests inline — don't delegate them.
+
+## Layout
+
+    src/alia/host.py     create_alia_agent — assembles a lovelaice Agent (persona, tools)
+    src/alia/agent.py    AliaAgent — in-process ACP client driving the lovelaice runtime
+    src/alia/persona.py  the system prompt (base passed to assemble_system_prompt)
+    src/alia/hud.py      the borderless GTK4 HUD (transcript + entry)
+    src/alia/app.py      resident single-instance Gtk.Application + asyncio bridge
+    src/alia/__main__.py python -m alia
+    scripts/install-shortcut.sh   binds a GNOME key (<Super>i) → ALIA
+    scripts/alia-launch.sh        logging launcher used by the shortcut
+    tests/test_agent.py  agent-core unit tests (offline via MockLLM)
+    Makefile             install / test / run / shortcut
+
+## Engine notes
+
+- Built on the **lovelaice agent runtime**, not bare lingo and not the legacy
+  `lovelaice.core.Lovelaice`. The chain is:
+  `host.create_alia_agent` → `lovelaice.agent.Agent` (ReActNative loop, JSONL
+  session) → driven via `AcpServer` + `InProcessAcpClient` (same path
+  lovelaice's CLI uses). This gives sessions, persistence, tool dispatch,
+  hooks, and MCP for free — we do NOT re-implement an agent loop.
+- **Persona** is the `system_prompt` base on `AgentConfig`; lovelaice's
+  `assemble_system_prompt` appends tool descriptions. No `Lingo.format()` here,
+  so the persona prompt is plain text (brace constraint no longer applies, but
+  keep it clean).
+- **Streaming:** ACP emits `agent_message_chunk` with the *finalized* assistant
+  text (one chunk per turn in VS1), tool calls as their own notifications. The
+  HUD shows the chunk when it arrives. Token-level streaming is a later rung.
+- **Tools / MCP** wire into `host.create_alia_agent` (currently `tools=[]`).
+- Sessions persist to `~/.alia/sessions/<ts>.jsonl` (ALIA's `$HOME` store). The
+  beaverdb `ConversationStore` is the richer next layer (pass
+  `conversation_store=` to `AcpServer`).
+- Model/endpoint resolve from env (`ALIA_*` → generic → defaults: Haiku over
+  OpenRouter).
+
+## Runtime/env gotcha
+
+GTK PyGObject (`gi`) comes from the **system** (distro `python3-gobject`), not
+pip — so the venv is built with `--system-site-packages` (see Makefile). A plain
+isolated venv won't find `gi`.
+
+## Capability surface (v1.0)
+
+- Tools: `read` (auto-allowed) + `bash` (approval-gated). Gate is an async
+  `tool_call` hook in `host.create_alia_agent`. Order: `bash_prefix_guard`
+  (hard red-line) → policy check → `approval_handler`.
+- `policy.py` decides auto-approval: `is_auto_safe` (read-only allowlist +
+  safe sub-commands) and `matches_prefix` (session-approved prefixes). A
+  command with shell operators (`;|><&&$(`) NEVER auto-approves — always
+  prompts. Tests in `test_policy.py` (pure, safety-critical).
+- The handler returns `"deny" | "once" | "session"`; `"session"` adds
+  `approval_prefix(command)` to a per-launch set (`AliaAgent.approved_prefixes`)
+  shared with the hook. The HUD bar shows three buttons.
+- NOTE: lovelaice's own `AskUser`/`session/request_permission` is VS2 / not
+  wired, so we do NOT use it — ALIA owns the approval bridge in-process.
+
+## Out of scope (still ahead)
+
+Screen perception (screenshots/vision, AT-SPI), mouse/keyboard control, the full
+autonomy dial (session-allow / allow-lists), persistent `$HOME` *memory* (vs
+session transcripts), named desktop tools (launch_app/notify/…), .deb packaging,
+KDE. All in the vision doc as next rungs.

alia_ai-1.1.0/Makefile

@@ -0,0 +1,32 @@
+# ALIA — dev makefile.
+#
+# The venv is created with --system-site-packages so the distro's GTK4
+# PyGObject (python3-gobject) is visible without compiling it into the venv.
+
+VENV := .venv
+PY := $(VENV)/bin/python
+PIP := $(VENV)/bin/pip
+
+.PHONY: install test run shortcut clean
+
+install: $(VENV)/.stamp
+
+$(VENV)/.stamp: pyproject.toml
+	python3 -m venv --system-site-packages $(VENV)
+	-$(PIP) install -U pip
+	$(PIP) install -e .
+	$(PIP) install pytest pytest-asyncio
+	touch $@
+
+test: install
+	$(PY) -m pytest -q
+
+run: install
+	$(PY) -m alia
+
+# Bind a GNOME shortcut (default <Super>a) that summons ALIA.
+shortcut: install
+	./scripts/install-shortcut.sh
+
+clean:
+	rm -rf $(VENV)

alia_ai-1.1.0/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: alia-ai
+Version: 1.1.0
+Summary: ALIA — the cognitive partner of the AI-n-Box desktop. A native GNOME agent surface on the lingo/lovelaice engine.
+Author-email: Alejandro Piad <apiad@apiad.net>
+Requires-Python: >=3.13
+Requires-Dist: lovelaice>=2.1.0
+Requires-Dist: python-dotenv>=1.0
+Description-Content-Type: text/markdown
+
+# ALIA
+
+**ALIA** — the cognitive partner of the AI-n-Box desktop. A native GNOME agent
+you summon with a key, backed by the [lovelaice](https://github.com/apiad/lovelaice)
+agent runtime (sessions, persistence, tools, MCP) over its ACP engine.
+
+This repo is the **standalone** slice: ALIA installs and runs on any recent
+GNOME, independent of AI-n-Box OS (where she'll later be baked in and pre-wired
+to the local Ollama daemon).
+
+> Vision: `vault/Atlas/Architecture/2026-06-25-alia-cognitive-partner-vision.md`
+> in the Workspace.
+
+## What works today (v1.0)
+
+- A borderless GNOME HUD with a **WebKit transcript** — real markdown +
+  syntax highlighting (reuses superbot's `marked`/`highlight`), an in-page
+  "working…" spinner, and input locked while a turn runs. **Enter** sends,
+  **Esc** hides.
+- A resident single-instance app — pressing the shortcut again toggles the HUD;
+  the agent stays alive in the background.
+- **She acts on your machine via the shell**, with you in the loop:
+  - `read(path)` — reads any file, **silently** (observation is free).
+  - `bash(command)` — runs a shell command. **Well-known read-only commands
+    auto-run** (`ls`, `cat`, `df`, `git status`, …); anything else shows an
+    inline bar with **Deny / Approve / Permitir «prefix» esta sesión**. Picking
+    the session option auto-approves that command *prefix* (e.g. `git push`,
+    `npm install`) for the rest of the run. This is how she manages files,
+    launches apps, changes GNOME settings, inspects the system, uses git, …
+  - **Safety floor:** any command containing shell operators (`;`, `|`, `>`,
+    `&&`, `$(…)`) always prompts — a safe lead can't smuggle a dangerous tail.
+    Hard red-lines (`sudo`, `rm -rf /` …) are blocked outright. Tool activity is
+    shown in the transcript as it happens.
+- Conversation persists per session to `~/.alia/sessions/<ts>.jsonl`.
+- Model-agnostic via the lovelaice engine: defaults to **Haiku over OpenRouter**
+  (`anthropic/claude-haiku-4.5`), points anywhere OpenAI-compatible.
+
+**Not yet:** she can't *see* the screen (no screenshots/vision) or control the
+mouse/keyboard/click — those are the next rungs. She says so when asked.
+
+## Requirements
+
+- GNOME with **GTK 4** and its Python bindings (`python3-gobject` / PyGObject —
+  from your distro, not pip).
+- **WebKitGTK 6.0** for the transcript (`gir1.2-webkit-6.0` on Debian/Ubuntu;
+  `webkitgtk6.0` on Fedora).
+- Python ≥ 3.13.
+
+## Install
+
+```sh
+git clone https://github.com/syalia-srl/alia && cd alia
+./install.sh
+```
+
+`install.sh` installs ALIA user-local (no sudo for the app itself):
+
+- system GTK 4 + PyGObject + WebKitGTK 6.0 via `apt`/`dnf` — **only if missing**
+  (the one step that uses sudo);
+- a venv at `~/.local/share/alia/venv` with `alia` + the engine
+  (`lovelaice`/`lingo`/`beaver`) resolved from **PyPI**;
+- a launcher at `~/.local/bin/alia`, an app entry, and the `<Super>i` shortcut.
+
+Then configure a key and summon it:
+
+```sh
+mkdir -p ~/.config/alia
+echo 'ALIA_API_KEY=sk-or-...' >> ~/.config/alia/env   # any OpenAI-compatible key
+#   ALIA_MODEL=anthropic/claude-haiku-4.5   (optional)
+#   ALIA_BASE_URL=https://openrouter.ai/api/v1   (optional)
+```
+
+Press **`<Super>i`** (or run `alia`).
+
+## Install with pipx
+
+Requires the system GTK 4 + WebKitGTK libraries (see Requirements) — pipx's venv
+borrows them via `--system-site-packages`:
+
+```sh
+pipx install --system-site-packages alia      # PyPI (once published)
+# or, from the private repo:
+#   pipx install --system-site-packages git+ssh://git@github.com/syalia-srl/alia
+alia setup     # wires the <Super>i shortcut, .desktop entry, and config
+```
+
+`alia setup` is also safe to re-run anytime (re-checks deps, re-installs the
+shortcut). `install.sh` calls it under the hood.
+
+## Run from source (dev)
+
+```sh
+export ALIA_API_KEY="sk-or-..."
+make run          # builds .venv (--system-site-packages) and launches
+```
+
+`make run` starts the resident app. To summon it with a key:
+
+```sh
+make shortcut                 # binds <Super>i → ALIA
+BINDING='<Super>j' make shortcut   # or pick your own free key
+```
+
+**Picking a key.** Many obvious combos are already grabbed and will silently do
+nothing if you bind a custom shortcut to them: the bare Super/Windows key
+(Activities overview), `<Super>space` (ibus input-source switch — an
+*independent* grabber, so freeing the WM binding isn't enough), and often F12
+(terminal dropdowns). The default is **`<Super>i`** (mnemonic for *IA*). If a
+binding seems dead, it's almost certainly already taken — check
+`/tmp/alia-launch.log`: the launcher logs every time the shortcut actually
+fires, so an empty log means the key never reached ALIA.
+
+## Config
+
+| Env var | Default | Purpose |
+|---|---|---|
+| `ALIA_API_KEY` / `OPENROUTER_API_KEY` / `API_KEY` | — | API key |
+| `ALIA_MODEL` / `MODEL` | `anthropic/claude-haiku-4.5` | model slug |
+| `ALIA_BASE_URL` / `BASE_URL` | `https://openrouter.ai/api/v1` | endpoint |
+
+## Develop
+
+```sh
+make test     # agent-core unit tests (offline, via lingo's MockLLM)
+```
+
+The GTK HUD is smoke-tested manually (`make run`); the agent core is unit-tested.
+
+## Status
+
+Conventions: ships to `main`, vertical-slice-first. See `AGENTS.md`.

alia_ai-1.1.0/README.md

@@ -0,0 +1,131 @@
+# ALIA
+
+**ALIA** — the cognitive partner of the AI-n-Box desktop. A native GNOME agent
+you summon with a key, backed by the [lovelaice](https://github.com/apiad/lovelaice)
+agent runtime (sessions, persistence, tools, MCP) over its ACP engine.
+
+This repo is the **standalone** slice: ALIA installs and runs on any recent
+GNOME, independent of AI-n-Box OS (where she'll later be baked in and pre-wired
+to the local Ollama daemon).
+
+> Vision: `vault/Atlas/Architecture/2026-06-25-alia-cognitive-partner-vision.md`
+> in the Workspace.
+
+## What works today (v1.0)
+
+- A borderless GNOME HUD with a **WebKit transcript** — real markdown +
+  syntax highlighting (reuses superbot's `marked`/`highlight`), an in-page
+  "working…" spinner, and input locked while a turn runs. **Enter** sends,
+  **Esc** hides.
+- A resident single-instance app — pressing the shortcut again toggles the HUD;
+  the agent stays alive in the background.
+- **She acts on your machine via the shell**, with you in the loop:
+  - `read(path)` — reads any file, **silently** (observation is free).
+  - `bash(command)` — runs a shell command. **Well-known read-only commands
+    auto-run** (`ls`, `cat`, `df`, `git status`, …); anything else shows an
+    inline bar with **Deny / Approve / Permitir «prefix» esta sesión**. Picking
+    the session option auto-approves that command *prefix* (e.g. `git push`,
+    `npm install`) for the rest of the run. This is how she manages files,
+    launches apps, changes GNOME settings, inspects the system, uses git, …
+  - **Safety floor:** any command containing shell operators (`;`, `|`, `>`,
+    `&&`, `$(…)`) always prompts — a safe lead can't smuggle a dangerous tail.
+    Hard red-lines (`sudo`, `rm -rf /` …) are blocked outright. Tool activity is
+    shown in the transcript as it happens.
+- Conversation persists per session to `~/.alia/sessions/<ts>.jsonl`.
+- Model-agnostic via the lovelaice engine: defaults to **Haiku over OpenRouter**
+  (`anthropic/claude-haiku-4.5`), points anywhere OpenAI-compatible.
+
+**Not yet:** she can't *see* the screen (no screenshots/vision) or control the
+mouse/keyboard/click — those are the next rungs. She says so when asked.
+
+## Requirements
+
+- GNOME with **GTK 4** and its Python bindings (`python3-gobject` / PyGObject —
+  from your distro, not pip).
+- **WebKitGTK 6.0** for the transcript (`gir1.2-webkit-6.0` on Debian/Ubuntu;
+  `webkitgtk6.0` on Fedora).
+- Python ≥ 3.13.
+
+## Install
+
+```sh
+git clone https://github.com/syalia-srl/alia && cd alia
+./install.sh
+```
+
+`install.sh` installs ALIA user-local (no sudo for the app itself):
+
+- system GTK 4 + PyGObject + WebKitGTK 6.0 via `apt`/`dnf` — **only if missing**
+  (the one step that uses sudo);
+- a venv at `~/.local/share/alia/venv` with `alia` + the engine
+  (`lovelaice`/`lingo`/`beaver`) resolved from **PyPI**;
+- a launcher at `~/.local/bin/alia`, an app entry, and the `<Super>i` shortcut.
+
+Then configure a key and summon it:
+
+```sh
+mkdir -p ~/.config/alia
+echo 'ALIA_API_KEY=sk-or-...' >> ~/.config/alia/env   # any OpenAI-compatible key
+#   ALIA_MODEL=anthropic/claude-haiku-4.5   (optional)
+#   ALIA_BASE_URL=https://openrouter.ai/api/v1   (optional)
+```
+
+Press **`<Super>i`** (or run `alia`).
+
+## Install with pipx
+
+Requires the system GTK 4 + WebKitGTK libraries (see Requirements) — pipx's venv
+borrows them via `--system-site-packages`:
+
+```sh
+pipx install --system-site-packages alia      # PyPI (once published)
+# or, from the private repo:
+#   pipx install --system-site-packages git+ssh://git@github.com/syalia-srl/alia
+alia setup     # wires the <Super>i shortcut, .desktop entry, and config
+```
+
+`alia setup` is also safe to re-run anytime (re-checks deps, re-installs the
+shortcut). `install.sh` calls it under the hood.
+
+## Run from source (dev)
+
+```sh
+export ALIA_API_KEY="sk-or-..."
+make run          # builds .venv (--system-site-packages) and launches
+```
+
+`make run` starts the resident app. To summon it with a key:
+
+```sh
+make shortcut                 # binds <Super>i → ALIA
+BINDING='<Super>j' make shortcut   # or pick your own free key
+```
+
+**Picking a key.** Many obvious combos are already grabbed and will silently do
+nothing if you bind a custom shortcut to them: the bare Super/Windows key
+(Activities overview), `<Super>space` (ibus input-source switch — an
+*independent* grabber, so freeing the WM binding isn't enough), and often F12
+(terminal dropdowns). The default is **`<Super>i`** (mnemonic for *IA*). If a
+binding seems dead, it's almost certainly already taken — check
+`/tmp/alia-launch.log`: the launcher logs every time the shortcut actually
+fires, so an empty log means the key never reached ALIA.
+
+## Config
+
+| Env var | Default | Purpose |
+|---|---|---|
+| `ALIA_API_KEY` / `OPENROUTER_API_KEY` / `API_KEY` | — | API key |
+| `ALIA_MODEL` / `MODEL` | `anthropic/claude-haiku-4.5` | model slug |
+| `ALIA_BASE_URL` / `BASE_URL` | `https://openrouter.ai/api/v1` | endpoint |
+
+## Develop
+
+```sh
+make test     # agent-core unit tests (offline, via lingo's MockLLM)
+```
+
+The GTK HUD is smoke-tested manually (`make run`); the agent core is unit-tested.
+
+## Status
+
+Conventions: ships to `main`, vertical-slice-first. See `AGENTS.md`.

alia_ai-1.1.0/install.sh

@@ -0,0 +1,67 @@
+#!/usr/bin/env bash
+# Install ALIA as a user-local app: system deps + a venv + launcher + shortcut.
+#
+#   ./install.sh
+#
+# Installs into ~/.local (no sudo for the app itself; sudo is used ONLY to add
+# the GTK4/WebKit system libraries, and only if they're missing). The engine
+# (lovelaice + lingo + beaver) resolves from PyPI.
+set -euo pipefail
+
+REPO_DIR="$(cd "$(dirname "$0")" && pwd)"
+PREFIX="${ALIA_PREFIX:-$HOME/.local/share/alia}"
+VENV="$PREFIX/venv"
+BINDIR="$HOME/.local/bin"
+LAUNCHER="$BINDIR/alia"
+BINDING="${ALIA_BINDING:-<Super>i}"
+
+say() { printf '  %s\n' "$*"; }
+
+have_gui_deps() {
+  python3 - <<'PY' 2>/dev/null
+import gi
+gi.require_version("Gtk", "4.0")
+gi.require_version("WebKit", "6.0")
+from gi.repository import Gtk, WebKit  # noqa
+PY
+}
+
+install_system_deps() {
+  if have_gui_deps; then say "✓ GTK 4 + WebKitGTK 6.0 already present"; return; fi
+  say "Installing GTK 4 + PyGObject + WebKitGTK 6.0 (needs sudo)…"
+  if command -v apt >/dev/null 2>&1; then
+    sudo apt update && sudo apt install -y \
+      python3-venv python3-gi gir1.2-gtk-4.0 gir1.2-webkit-6.0
+  elif command -v dnf >/dev/null 2>&1; then
+    sudo dnf install -y python3 python3-gobject gtk4 webkitgtk6.0
+  else
+    echo "Unsupported distro — install GTK 4 + PyGObject + WebKitGTK 6.0 manually." >&2
+    exit 1
+  fi
+}
+
+echo "ALIA installer → $PREFIX"
+install_system_deps
+
+say "building venv…"
+rm -rf "$VENV"
+python3 -m venv --system-site-packages "$VENV"
+"$VENV/bin/pip" install -qU pip
+"$VENV/bin/pip" install -q "$REPO_DIR"   # alia + engine from PyPI
+
+mkdir -p "$BINDIR"
+cat > "$LAUNCHER" <<EOF
+#!/usr/bin/env bash
+exec "$VENV/bin/python" -m alia "\$@"
+EOF
+chmod +x "$LAUNCHER"
+say "✓ launcher: $LAUNCHER"
+
+# Wire .desktop + GNOME shortcut + config template (shared with pip/pipx installs).
+ALIA_BINDING="$BINDING" "$LAUNCHER" setup
+
+echo
+echo "Done."
+echo "  • Configure a key in ~/.config/alia/env (ALIA_API_KEY=…)"
+echo "  • Summon with ${BINDING}, or run: alia"
+case ":$PATH:" in *":$BINDIR:"*) : ;; *) echo "  • NOTE: add $BINDIR to PATH to run 'alia' directly" ;; esac

alia_ai-1.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+# Distribution name (PyPI): "alia" is taken. The import package and the CLI
+# command both stay `alia`.
+name = "alia-ai"
+version = "1.1.0"
+description = "ALIA — the cognitive partner of the AI-n-Box desktop. A native GNOME agent surface on the lingo/lovelaice engine."
+readme = "README.md"
+requires-python = ">=3.13"
+authors = [{ name = "Alejandro Piad", email = "apiad@apiad.net" }]
+dependencies = [
+    # The agent runtime: sessions, persistence, tools, MCP, hooks. ALIA is a
+    # consumer of lovelaice's ACP engine, not a re-implementation on bare lingo.
+    "lovelaice>=2.1.0",
+    "python-dotenv>=1.0",
+]
+# NOTE: PyGObject (the GTK4 binding) is NOT a pip dependency on purpose.
+# It comes from the system (distro `python3-gobject` + GTK4), and the venv
+# is created with --system-site-packages so it's visible. See the Makefile.
+
+[dependency-groups]
+dev = ["pytest>=8.3", "pytest-asyncio>=0.24"]
+
+[project.scripts]
+alia = "alia.app:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/alia"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

alia_ai-1.1.0/scripts/alia-launch.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+# Launcher used by the GNOME keybinding. Logs each invocation (so we can tell
+# whether the shortcut fired at all) then hands off to the resident app.
+LOG="${ALIA_LAUNCH_LOG:-/tmp/alia-launch.log}"
+REPO_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+{
+  echo "----"
+  echo "$(date '+%F %T') fired | WAYLAND_DISPLAY=${WAYLAND_DISPLAY:-} DISPLAY=${DISPLAY:-} DBUS=${DBUS_SESSION_BUS_ADDRESS:-}"
+} >> "$LOG" 2>&1
+exec "${REPO_DIR}/.venv/bin/python" -m alia >> "$LOG" 2>&1

alia_ai-1.1.0/scripts/install-shortcut.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+# Register a GNOME custom keyboard shortcut that summons ALIA.
+#
+# Default binding: <Super>i  (mnemonic for IA). Note that many obvious combos
+# are already grabbed and won't fire a custom shortcut:
+#   - the bare Super key      -> GNOME Activities overview
+#   - <Super>space            -> ibus input-source switch (independent grabber)
+#   - F12                     -> often a terminal-dropdown shortcut
+# If your chosen binding does nothing, it's almost certainly already taken.
+# Override with:  BINDING='<Super>j' ./scripts/install-shortcut.sh
+set -euo pipefail
+
+REPO_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+BINDING="${BINDING:-<Super>i}"
+# Launch via the wrapper (logs each fire to /tmp/alia-launch.log; handy for
+# diagnosing whether the shortcut fired at all).
+COMMAND="${REPO_DIR}/scripts/alia-launch.sh"
+SLOT="alia"
+BASE="org.gnome.settings-daemon.plugins.media-keys"
+PATH_PREFIX="/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings"
+KEYPATH="${PATH_PREFIX}/${SLOT}/"
+
+if ! command -v gsettings >/dev/null 2>&1; then
+  echo "gsettings not found — are you on GNOME?" >&2
+  exit 1
+fi
+
+# Append our slot to the custom-keybindings list without clobbering existing ones.
+python3 - "$BASE" "$KEYPATH" <<'PY'
+import ast, subprocess, sys
+base, keypath = sys.argv[1], sys.argv[2]
+cur = subprocess.check_output(["gsettings", "get", base, "custom-keybindings"]).decode().strip()
+try:
+    items = ast.literal_eval(cur) if cur and cur != "@as []" else []
+except (ValueError, SyntaxError):
+    items = []
+if keypath not in items:
+    items.append(keypath)
+subprocess.check_call(["gsettings", "set", base, "custom-keybindings", str(items)])
+PY
+
+SCHEMA="${BASE}.custom-keybinding:${KEYPATH}"
+gsettings set "$SCHEMA" name "ALIA"
+gsettings set "$SCHEMA" command "$COMMAND"
+gsettings set "$SCHEMA" binding "$BINDING"
+
+echo "Bound ${BINDING} → ${COMMAND}"
+echo "Change it in Settings → Keyboard → Custom Shortcuts, or re-run with BINDING=..."

alia_ai-1.1.0/src/alia/__init__.py

@@ -0,0 +1,7 @@
+"""ALIA — the cognitive partner of the AI-n-Box desktop.
+
+This is the standalone slice: a native GNOME HUD you summon with a key,
+backed by the lingo/lovelaice engine. Chat only for now — no tools yet.
+"""
+
+__version__ = "1.1.0"

alia_ai-1.1.0/src/alia/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .app import main
+
+if __name__ == "__main__":
+    sys.exit(main())