Metadata-Version: 2.4
Name: groon-aios
Version: 2.1.27
Summary: The AIOS agent in your terminal
Author: GROON
License-Expression: LicenseRef-Proprietary
Project-URL: Homepage, https://www.groon.io
Keywords: aios,agent,cli,groon
Classifier: Development Status :: 3 - Alpha
Classifier: Environment :: Console
Classifier: Operating System :: MacOS :: MacOS X
Classifier: Operating System :: POSIX :: Linux
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Rust
Requires-Python: >=3.10
Description-Content-Type: text/markdown
Requires-Dist: httpx<1,>=0.27
Requires-Dist: prompt-toolkit<4,>=3.0.48
Requires-Dist: rich<15,>=14
Requires-Dist: packaging<27,>=24

# AIOS CLI

Use the AIOS agent from your terminal, connected to your AIOS account.

```sh
pip install groon-aios
aios
```

On first launch, choose your platform domain (default `www.groon.io`), sign in
with your email or username and password, and select an account when more than
one matches. AIOS asks you to trust a project before accessing it. Available
models come from your platform account.

Running `aios` without a request opens the fullscreen interface, including
sign-in and project access. Running `aios <request>` prints one response in
your existing terminal and exits. Complete sign-in and project access once
with `aios` before using shortcut mode.
Startup shows the GROON logo immediately, with progress in an animated subline.
The same fullscreen surface then shows your chats, or just the logo when empty.

Sessions are stored locally under your user workspace in `~/.aios`, alongside
the brain shared with the AIOS app. CLI credentials and preferences have their
own private directory. The CLI synchronizes brain files with AIOS independently
of the desktop app.

The chats overview is scoped to the directory where you started `aios`.
A new directory starts with an empty list; type in the prompt to begin a chat.
The prompt is focused initially. Press Up to select the bottom chat, then use
Up/Down and Enter; typing moves straight back to the prompt.
Chats receive a short AI-generated title after the first prompt. Existing chats
without a generated title are named in the background when you open the CLI.
Select a chat and press Ctrl+D to delete it after confirmation; a running chat
is stopped before its local files are removed. Use `/exit` to exit AIOS.
The model picker loads the language models from your platform's
`/api/ai/ai_models/` catalog and keeps their AIOS model references when selected.

Use `/` for commands, `/settings` for preferences, and `/logout` to sign out.
Use the arrow keys to move through menus, Enter to select, and Esc to cancel.
`/model` (or `/models`) opens the model picker. Esc or `/back` returns from a
conversation to the overview while its agent continues working in the background.
Open another chat or start a new one; running chats keep their own messages and
pending requests. The overview marks chats that need an answer or approval.
Ctrl+C stops the current chat; exiting the CLI stops all remaining runs.
Saved sessions can be selected from the overview or `/sessions`.
Questions and approvals replace the bottom prompt with selectable answers. Use
Up/Down and Enter, or type a reply when free text is allowed. Esc returns to the
overview without answering or granting permission. Unanswered questions remain
available after a run finishes. Current activity appears above the composer,
with a wave that animates independently of transcript rendering.
Scroll within the conversation with the mouse wheel or Page Up / Page Down;
the header and composer remain in place. Agent replies render Markdown tables,
code blocks, emphasis and lists, with prose wrapping at word boundaries. Terminal mouse reporting must be
enabled for wheel scrolling.
Type `@` to choose a project file, folder, or accessible AIOS object. Local paths
come from a private cached index, while AIOS results load in the background.
Use Up/Down and Enter or Tab to insert a mention; Esc closes the picker. The
agent receives the exact path or AIOS reference for selected items. Indexing
stores path names only and never uploads project files. Generated, ignored and
private directories are excluded from the path suggestions.

Shift+Tab cycles the agent modes. `/goal` (or `/ziel`) keeps the agent working
until it explicitly finishes the goal; `/subagents` enables delegated agents.

For a quick command suggestion using the last selected model:

```sh
aios show all folders
```

Shortcut prompts have a separate history from interactive sessions.

The package contains the shared Rust agent runtime, its embedded skills and the
Python terminal interface. It does not contain the AIOS backend or frontend.
Platform wheels support macOS 11 or newer (Intel and Apple Silicon) and Linux
with glibc 2.28 or newer (x86-64 and ARM64), with Python 3.10 or newer. Installing
from the source distribution requires a current Rust toolchain and a C linker.

An AIOS platform version that supports the CLI endpoints is required. The
package name is `groon-aios`; the installed terminal command is `aios`.

## Updates

Each interactive launch checks the latest stable `groon-aios` release on PyPI.
If an update is available, choose **Update now** or **Not now** using the arrow
keys and Enter. Offline checks do not prevent startup. `/update` checks again
on demand; finish or stop running chats before installing. Installation uses
the current Python environment and restarts the CLI after verifying the version.

Source and editable installations still check PyPI, but never install over the
checkout or change the source-linked `aios` launcher. Update your source checkout
through your usual Git workflow instead. Shortcut requests stay noninteractive.

## Local development

From the repository root, install the CLI in an isolated Python environment:

```sh
python3 -m venv .venv-aios-cli
.venv-aios-cli/bin/python -m pip install -e ./agent
.venv-aios-cli/bin/aios
```

The editable install compiles the shared Rust runtime. It requires Rust/Cargo
and the platform C linker. Choose `http://127.0.0.1:8000` during onboarding when
using the local Django backend, and sign in with an account on that backend.
The backend must include the CLI endpoints in this checkout.

If you already have Python with `httpx`, `prompt_toolkit`, `rich` and `packaging`, you can open the
interface and use shortcut mode directly from source:

```sh
PYTHONPATH=agent/python python -m aios_cli
PYTHONPATH=agent/python python -m aios_cli show all folders
```

Source launchers can set `AIOS_CLI_BUILD_RUNTIME=1` to prepare the Rust runtime
behind the fullscreen startup logo. `AIOS_CLI_CARGO` can specify the Cargo
executable. This preparation runs only for an interactive launch.

Interactive agent turns also need the new native runtime. To build it separately
and use the source interface:

```sh
cargo build --manifest-path agent/Cargo.toml --package agent-cli --bin aios-agent
AIOS_CLI_RUNTIME="$PWD/agent/target/debug/aios-agent" PYTHONPATH=agent/python python -m aios_cli
```

Run `aios --logout` (or `python -m aios_cli --logout` with the source command)
to switch between local and hosted accounts. The CLI keeps local sessions and
brain notes when you sign out.
