# 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
```

## Starta Applikationen

För att starta applikationen i utvecklingsläge:

```bash
cargo tauri dev
```

### Felsökning: Linux (Wayland) & "Error 71"
Om du använder Linux med Wayland (t.ex. GNOME eller KDE Plasma) kan du stöta på "Error 71 (Protocol error)" vid start. Detta är en känd bugg relaterad till WebKitGTK och hårdvaruacceleration.

**Lösning:**
Kör applikationen med inaktiverad kompositering:

```bash
WEBKIT_DISABLE_COMPOSITING_MODE=1 cargo tauri dev
```

Alternativt för vissa NVIDIA-konfigurationer:
```bash
__NV_DISABLE_EXPLICIT_SYNC=1 cargo tauri dev
```

### 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.

## Loggning

Applikationen har inbyggt stöd för loggning för att underlätta felsökning.

*   **Plats:** Loggfiler sparas i en mapp som heter `loggs` som ligger i samma katalog som den körbara filen.
*   **Filnamn:** En loggfil skapas per dag och döps efter dagens datum (t.ex. `2024-01-18.log`).
*   **Format:** Loggarna innehåller tidsstämpel, loggnivå (INFO, DEBUG, ERROR), modul/funktion samt meddelandet. Exempel:
    `[2024-01-18 10:00:00][INFO][ai_translater_client::main] Application started`
*   **Loggade händelser:** Applikationsstart, system tray-händelser, felmeddelanden och annan viktig information loggas.