feat: Add VS Code configuration and icon assets for Tauri application

.gitignore

@@ -7,10 +7,11 @@
 .DS_Store
 Thumbs.db
 
-# VS Code
-.vscode/
+# VS Code - Ignore everything but project-specific config
+.vscode/*
 !.vscode/launch.json
 !.vscode/tasks.json
+!.vscode/extensions.json
 
 # Node / Frontend (om det läggs till senare)
 node_modules/

.vscode/extensions.json

@@ -0,0 +1,7 @@
+{
+    "recommendations": [
+        "vadimcn.vscode-lldb",
+        "tauri-apps.tauri-vscode",
+        "rust-lang.rust-analyzer"
+    ]
+}

.vscode/launch.json

@@ -0,0 +1,19 @@
+{
+  "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",
+      "env": {
+        "WEBKIT_DISABLE_COMPOSITING_MODE": "1",
+        // "GDK_BACKEND": "x11" // Uncomment if the above doesn't fix the initialization error
+      },
+      "sourceLanguages": ["rust"]
+    }
+  ]
+}

.vscode/tasks.json

@@ -0,0 +1,69 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "build",
+      "type": "shell",
+      "command": "cargo",
+      "args": [
+        "build",
+        "--manifest-path=./src-tauri/Cargo.toml",
+        "--no-default-features"
+      ],
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      },
+      "problemMatcher": [
+        "$rustc"
+      ]
+    },
+    {
+      "label": "Build Release (Linux)",
+      "type": "shell",
+      "command": "cargo",
+      "args": [
+        "tauri",
+        "build"
+      ],
+      "options": {
+        "cwd": "${workspaceFolder}/src-tauri"
+      },
+      "group": "build",
+      "problemMatcher": []
+    },
+    {
+      "label": "Build Release (Windows)",
+      "type": "shell",
+      "command": "cargo",
+      "args": [
+        "tauri",
+        "build",
+        "--target",
+        "x86_64-pc-windows-msvc"
+      ],
+      "options": {
+        "cwd": "${workspaceFolder}/src-tauri"
+      },
+      "group": "build",
+      "problemMatcher": []
+    },
+    {
+      "label": "tauri dev",
+      "type": "shell",
+      "command": "cargo",
+      "args": [
+        "tauri",
+        "dev"
+      ],
+      "options": {
+        "cwd": "${workspaceFolder}/src-tauri",
+         "env": {
+             "WEBKIT_DISABLE_COMPOSITING_MODE": "1"
+         }
+      },
+      "group": "build",
+      "problemMatcher": []
+    }
+  ]
+}

README.md

@@ -1,85 +1,21 @@
 # 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.
+En smart skrivbordsassistent utvecklad i Rust och Tauri v2. Applikationen hjälper dig att översätta, rättstava och förbättra text i realtid genom att integrera lokala AI-modeller (Ollama) eller molntjänster (OpenAI) direkt i ditt arbetsflöde.
 
-## Projektbeskrivning
+## 🚀 Komma Igång
 
-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).
+### Förutsättningar
 
-### Kärnfunktionalitet
+För att utveckla och bygga applikationen behöver du följande installerat:
 
-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 \
+1.  **Rust & Cargo**:
+    ```bash
+    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+    ```
+2.  **System-beroenden (Linux/Debian/Ubuntu)**:
+    ```bash
+    sudo apt update
+    sudo apt install libwebkit2gtk-4.1-dev \
         build-essential \
         curl \
         wget \
@@ -88,137 +24,87 @@ sudo apt install libwebkit2gtk-4.1-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:**
+3.  **Cross-compilation (Windows från Linux)**:
+    Om du vill bygga för Windows från Linux behöver du `nsis` samt Rust-målet för Windows:
     ```bash
     rustup target add x86_64-pc-windows-msvc
+    # Observera att cross-compilation med MSVC kan kräva ytterligare konfiguration (libs).
+    # Alternativt använd x86_64-pc-windows-gnu om du har Mingw installerat.
     ```
 
-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/`.
+## 💻 Utveckling i VS Code
 
-## Windows-testning på Linux (Wine/Proton)
+Det här projektet är konfigurerat för en smidig upplevelse i VS Code.
 
-För att snabbt verifiera att Windows-bygget startar utan att byta OS:
+### Rekommenderade Tillägg
+VS Code kommer automatiskt rekommendera dessa, men se till att du har:
+*   **rust-analyzer** (Rust språkstöd)
+*   **Tauri** (Tauri verktyg)
+*   **CodeLLDB** (För debugging)
 
-1. **Installera Wine:**
-   ```bash
-   sudo apt install wine64
-   ```
+### Debugging (Felsökning)
+Du kan köra och debugga appen direkt inifrån redigeraren:
 
-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.*
+1.  Gå till **Run and Debug** fliken (Ctrl+Shift+D).
+2.  Välj **"Debug Tauri App"** i menyn.
+3.  Tryck **F5** (Play).
+    *   *Detta bygger appen och startar debuggern automatiskt. Du kan sätta breakpoints i din Rust-kod.*
 
-## Packaging & Distribution
+### Bygga för Release 📦
+För att skapa färdiga körbara filer (binärer) utan debug-info:
 
-Tauri hanterar paketering automatiskt baserat på ditt OS.
+1.  Öppna **Command Palette** (Ctrl+Shift+P).
+2.  Skriv och välj **"Tasks: Run Task"**.
+3.  Välj en av följande:
+    *   **Build Release (Linux)**: Skapar en optimerad build för Linux.
+        *   *Resultat:* `src-tauri/target/release/bundle/deb/` (eller AppImage)
+    *   **Build Release (Windows)**: Skapar en `.exe` för Windows.
+        *   *Resultat:* `src-tauri/target/x86_64-pc-windows-msvc/release/bundle/msi/` (eller nsis)
 
-### Linux (.deb & .AppImage)
+---
+
+## 📂 Projektstruktur
+
+Så här hittar du i koden:
+
+*   **`src-tauri/`**: Backend-koden (Rust) och Tauri-konfigurationen.
+    *   `Cargo.toml`: Beroenden för Rust.
+    *   `tauri.conf.json`: Inställningar för fönster, ikoner, behörigheter och bundles.
+    *   `build.rs`: Byggscript.
+    *   **`src/`**: Källkoden för backend.
+        *   `main.rs`: Entry point.
+        *   `controllers/`: Logik för applikationens tillstånd och kommandon.
+        *   `viewers/`: Hantering av fönster och System Tray.
+        *   `utilities/`: Hjälpfunktioner (loggning, config).
+*   **`dist/`**: (Frontend) Om du har en frontend (HTML/JS/CSS) ligger de kompilerade filerna här som Tauri laddar.
+*   **`.vscode/`**: Inställningar för debugging och tasks i VS Code.
+
+---
+
+## 🛠 Felsökning
+
+### Error 71 (Protocol Error) på Linux (Wayland)
+Om appen kraschar eller inte startar på Wayland:
+Debuggern är konfigurerad att automatiskt sätta `WEBKIT_DISABLE_COMPOSITING_MODE=1`.
+Om du kör manuellt från terminalen:
 ```bash
-cargo tauri build
+WEBKIT_DISABLE_COMPOSITING_MODE=1 cargo tauri dev
 ```
-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).
+### Debuggern startar inte
+*   Kontrollera att du installerat **CodeLLDB** tillägget.
+*   Om du får fel vid länkning, kontrollera att du har alla system-beroenden installerade (se "Förutsättningar").
 
-## 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
+## 🧠 Teknisk Stack
 
-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.
+*   **Core**: Rust
+*   **Framework**: Tauri v2
+*   **Input Monitoring**: `enigo` (tangentbords-simulering), `global-hotkey` (genvägar)
+*   **Clipboard**: `arboard`
+*   **AI**: `ollama-rs` (lokal) & `reqwest` (API)
 

src-tauri/.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+  "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"]
+    }
+  ]
+}

src-tauri/icons/android/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+  <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+  <background android:drawable="@color/ic_launcher_background"/>
+</adaptive-icon>

src-tauri/icons/android/values/ic_launcher_background.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <color name="ic_launcher_background">#fff</color>
+</resources>