# AI Typist Client

En cross-platform skrivbordsapplikation utvecklad i Rust och Tauri v2 för Windows 11 och Linux (med Wayland-stöd). Applikationen fungerar som en smart AI-assistent som integrerar sömlöst med ditt arbetsflöde via system-tray, globala genvägar och urklippshantering.

## Projektbeskrivning

Målet med detta projekt är att skapa ett verktyg som kan förbättra, rättstava eller översätta text i alla applikationer genom att utnyttja lokala LLM:er (via Ollama) eller molnbaserade API:er (OpenAI).

### Kärnfunktionalitet

1.  **System Tray Integration**:
    *   Applikationen körs i bakgrunden med en ikon i statusfältet/systemfältet.
    *   Högerklick ger en meny för att komma åt inställningar eller avsluta appen.

2.  **AI-Workflow**:
    *   **Input**: Appen hämtar text direkt från systemets urklipp (clipboard).
    *   **Bearbetning**: Texten bakas in i en prompt och skickas till en LLM (Ollama/OpenAI) för översättning eller rättstavning.
    *   **Output**: Det bearbetade svaret kan antingen:
        *   Kopieras tillbaka till urklipp.
        *   Skrivas ut direkt i det aktiva fönstret genom att imitera tangentbordstryckningar (Keyboard Mimicry).

3.  **Teknisk Stack**:
    *   **Språk**: Rust
    *   **GUI/Ramverk**: Tauri v2
    *   **Tangentbord/Input**: `enigo` (mimic) & `global-hotkey` (lyssna)
    *   **Urklipp**: `arboard`
    *   **AI-Kommunikation**: `reqwest` & `ollama-rs`

## Förutsättningar

Du behöver Rust installerat (rekommenderat via `rustup`).

**Installera Rust (Linux/macOS):**
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# Följ instruktionerna på skärmen (standardinstallation är oftast bäst)
source $HOME/.cargo/env
```

**Felsökning: "cannot install while Rust is installed"**
Om du får detta felmeddelande har du redan Rust installerat via systemets pakethanterare (vilket sällan stöder cross-compilation smidigt).

*Lösning:* Avinstallera system-versionen och kör scriptet igen.

*   **Arch Linux:** `sudo pacman -Rs rust` (Kolla även om du har `cargo` installerat separat)
*   **Ubuntu/Debian:** `sudo apt remove rustc cargo`

**Verifiera installationen:**
```bash
rustc --version
cargo --version
```

### Linux-beroenden (Ubuntu/Debian)
För att kompilera Tauri på Linux krävs följande bibliotek:

```bash
sudo apt update
sudo apt install libwebkit2gtk-4.1-dev \
    build-essential \
    curl \
    wget \
    file \
    libssl-dev \
    libgtk-3-dev \
    libayatana-appindicator3-dev \
    librsvg2-dev
```

### Linux-beroenden (Arch Linux / Manjaro)
```bash
sudo pacman -Syu
sudo pacman -S webkit2gtk-4.1 \
    base-devel \
    curl \
    wget \
    file \
    openssl \
    gtk3 \
    libayatana-appindicator \
    librsvg
```

*Obs: För Wayland-stöd hanterar GTK3/4 detta oftast automatiskt, men säkerställ att du kör en modern distribution.*

## Utveckling

### Installera Tauri CLI
```bash
cargo install tauri-cli --version "^2.0.0"
```

### Kör i utvecklingsläge
Gå in i `src-tauri` mappen eller kör från roten om konfigurerat korrekt, men standard är:
```bash
cd src-tauri
cargo tauri dev
```
Detta kommer starta applikationen. Eftersom vi inte har en frontend (HTML/JS) ännu, kommer fönstret vara tomt eller vitt, men System Tray-ikonen ska synas.

## Debugging med VS Code (CodeLLDB)

För att debugga Rust-koden effektivt i VS Code, skapa filen `.vscode/launch.json` i roten av projektet med följande innehåll. Detta binder CodeLLDB till Tauri-processen.

```json
{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Debug Tauri App",
      "type": "lldb",
      "request": "launch",
      "program": "${workspaceFolder}/src-tauri/target/debug/ai-translater-client",
      "args": [],
      "cwd": "${workspaceFolder}/src-tauri",
      "preLaunchTask": "build",
      "sourceLanguages": ["rust"]
    }
  ]
}
```

## Cross-Compilation: Windows 11 från Linux

Att bygga Windows `.exe` från Linux är fullt möjligt med `cargo-xwin`.

1. **Installera cross-kompileringsverktyg:**
   
   **Ubuntu/Debian:**
   ```bash
   sudo apt install mingw-w64
   ```

   **Arch Linux:**
   ```bash
   sudo pacman -S mingw-w64 clang lld
   # Välj "alla" (tryck Enter) om du tillfrågas om medlemmar i gruppen
   ```

   **Alla:**
   ```bash
   cargo install cargo-xwin
   ```

2. **Lägg till Windows target:**
   ```bash
   rustup target add x86_64-pc-windows-msvc
   ```

3. **Bygg för Windows:**
   Stå i `src-tauri` mappen och kör:
   ```bash
   cargo tauri build --target x86_64-pc-windows-msvc --runner cargo-xwin
   ```
   
   Resultatet (exe & msi) hamnar i `src-tauri/target/x86_64-pc-windows-msvc/release/bundle/`.

## Windows-testning på Linux (Wine/Proton)

För att snabbt verifiera att Windows-bygget startar utan att byta OS:

1. **Installera Wine:**
   ```bash
   sudo apt install wine64
   ```

2. **Kör applikationen:**
   Navigera till output-mappen från steget ovan och kör:
   ```bash
   wine "ai-translater-client.exe"
   ```
   *Notera: System Tray kan bete sig annorlunda i Wine än i äkta Windows.*

## Packaging & Distribution

Tauri hanterar paketering automatiskt baserat på ditt OS.

### Linux (.deb & .AppImage)
```bash
cargo tauri build
```
Filerna genereras i `src-tauri/target/release/bundle/deb/` och `appimage/`.

### Windows (.msi & .exe)
När du bygger via `cargo-xwin` (se ovan) eller på en Windows-maskin, genereras en `.msi` via WiX Toolset (om installerat) eller en `.exe` setup-fil via NSIS (standard i v2).

## Projektstruktur
* `src-tauri/Cargo.toml`: Alla beroenden (tauri, enigo, ollama-rs, etc).
* `src-tauri/src/main.rs`: Entry point. Innehåller logik för System Tray.
* `src-tauri/tauri.conf.json`: Konfiguration för fönster och byggprocess.