feat: add shareable profile image generation

- Add 1920x1080 HD canvas with trans-pride themed design
- Include profile avatar, name, bio, and lifetime stats
- Show achievement progress with visual progress bar
- Use Tauri fs plugin for cross-platform file reading
- Add scoped file permissions for read/write access

.gitea/workflows/ci.yml

@@ -49,13 +49,13 @@ jobs:
       - name: Run Svelte Check
         run: pnpm check
 
-      - name: Run frontend tests with coverage
+      - name: Run frontend tests
-        run: pnpm test:coverage
+        run: pnpm test
 
       - name: Setup Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          components: clippy, llvm-tools-preview
+          components: clippy
 
       - name: Cache Rust dependencies
         uses: actions/cache@v4
@@ -68,16 +68,13 @@ jobs:
             src-tauri/target/
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
-      - name: Install cargo-llvm-cov
-        run: cargo install cargo-llvm-cov --locked
-
       - name: Run Clippy
         working-directory: src-tauri
         run: cargo clippy --all-targets --all-features -- -D warnings
 
-      - name: Run Rust tests with coverage
+      - name: Run Rust tests
         working-directory: src-tauri
-        run: cargo llvm-cov --fail-under-lines 50
+        run: cargo test
 
   build-linux:
     name: Build Linux

.gitignore

@@ -8,6 +8,3 @@ node_modules
 !.env.example
 vite.config.js.timestamp-*
 vite.config.ts.timestamp-*
-
-# Coverage reports
-/coverage

RELEASE_NOTES_v0.3.0.md

@@ -0,0 +1,74 @@
+# Hikari Desktop v0.3.0 Release Notes
+
+## New Features
+
+### AskUserQuestion Tool Support (#51)
+
+- Claude can now ask you questions with multiple choice options during conversations
+- A dedicated modal appears with answer choices and support for custom responses
+- Answers are seamlessly integrated back into the conversation context
+
+### Slash Commands
+
+- `/cd <path>` - Change the working directory while preserving conversation context (#55)
+- `/search <query>` - Search and highlight matches within the conversation (#32)
+- `/skill <name> [data]` - Invoke Claude Code skills from `~/.claude/skills/` (#57)
+- `/new`, `/clear`, `/rename`, `/help` commands for conversation management (#6)
+
+### Auto-Update Checker (#17)
+
+- Automatically checks for new releases on startup
+- Notification appears when a newer version is available
+- Can be disabled in settings
+
+### Font Size & Zoom (#19)
+
+- Adjust font size with keyboard shortcuts: `Ctrl++`, `Ctrl+-`, `Ctrl+0`
+- Font size slider in settings (10-24px range)
+- Preference persists between sessions
+
+### Resizable Character Panel (#10)
+
+- Drag the divider between the character panel and terminal to resize
+- Panel width is saved and restored on app restart
+- Sprite now uses full height for better proportions
+
+### Input History Navigation (#13)
+
+- Use up/down arrows to navigate through previous messages and commands
+- Arrow keys only navigate history when input is empty - otherwise they move the cursor (#58)
+
+### Keyboard Shortcuts (#21)
+
+- `Ctrl+N` - New conversation
+- `Ctrl+W` - Close current tab
+- `Ctrl+Tab` / `Ctrl+Shift+Tab` - Switch between tabs
+- `Ctrl+L` - Clear conversation
+- `Ctrl+,` - Open settings
+
+### Always On Top Toggle (#28)
+
+- Pin the window to stay above other applications
+- Toggle in settings
+
+## Improvements
+
+### UI/UX
+
+- Resizable chat input with drag handle (expands upward)
+- Send button properly aligned with input field
+- Markdown rendering with syntax-highlighted code blocks (#31, #33)
+- Light mode text colors improved for better readability
+- Scroll position persists per conversation tab when switching
+- Confirmation modal when closing connected tabs
+- Links in chat now open in default browser (#54)
+- Spaces allowed when renaming tabs (#52)
+
+### State Management
+
+- Stats (tokens, cost) persist across session changes and only reset on disconnect (#59)
+- Multiple tabs can now request permissions simultaneously without conflicts
+
+## Closed Issues
+
+#6, #10, #13, #17, #19, #21, #28, #31, #32, #33, #51, #52, #54, #55, #57, #58, #59

eslint.config.js

@@ -27,6 +27,6 @@ export default tseslint.config(
     },
   },
   {
-    ignores: ["build/", ".svelte-kit/", "dist/", "src-tauri/target/", "node_modules/", "coverage/"],
+    ignores: ["build/", ".svelte-kit/", "dist/", "src-tauri/target/", "node_modules/"],
   }
 );

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hikari-desktop",
-  "version": "1.0.0",
+  "version": "0.3.0",
   "description": "",
   "type": "module",
   "scripts": {
@@ -16,10 +16,6 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
-    "test:backend": "cd src-tauri && cargo test",
-    "test:backend:coverage": "cd src-tauri && cargo llvm-cov --text",
-    "test:all": "pnpm test && pnpm test:backend",
-    "coverage:all": "pnpm test:coverage && pnpm test:backend:coverage",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier --write .",
@@ -48,7 +44,6 @@
     "@tauri-apps/cli": "^2",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/svelte": "^5.3.1",
-    "@vitest/coverage-v8": "^4.0.18",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-svelte": "^3.14.0",

pnpm-lock.yaml

@@ -66,9 +66,6 @@ importers:
       '@testing-library/svelte':
         specifier: ^5.3.1
         version: 5.3.1(svelte@5.46.3)(vite@6.4.1(jiti@2.6.1)(lightningcss@1.30.2))(vitest@4.0.17(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2))
-      '@vitest/coverage-v8':
-        specifier: ^4.0.18
-        version: 4.0.18(vitest@4.0.17(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2))
       eslint:
         specifier: ^9.39.2
         version: 9.39.2(jiti@2.6.1)
@@ -133,31 +130,14 @@ packages:
     resolution: {integrity: sha512-JYgintcMjRiCvS8mMECzaEn+m3PfoQiyqukOMCCVQtoJGYJw8j/8LBJEiqkHLkfwCcs74E3pbAUFNg7d9VNJ+Q==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-string-parser@7.27.1':
-    resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==}
-    engines: {node: '>=6.9.0'}
-
   '@babel/helper-validator-identifier@7.28.5':
     resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/parser@7.28.6':
-    resolution: {integrity: sha512-TeR9zWR18BvbfPmGbLampPMW+uW1NZnJlRuuHso8i87QZNq2JRF9i6RgxRqtEq+wQGsS19NNTWr2duhnE49mfQ==}
-    engines: {node: '>=6.0.0'}
-    hasBin: true
-
   '@babel/runtime@7.28.6':
     resolution: {integrity: sha512-05WQkdpL9COIMz4LjTxGpPNCdlpyimKppYNoJ5Di5EUObifl8t4tuLuUBBZEpoLYOmfvIWrsp9fCl0HoPRVTdA==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/types@7.28.6':
-    resolution: {integrity: sha512-0ZrskXVEHSWIqZM/sQZ4EV3jZJXRkio/WCxaqKZP1g//CEWEPSfeZFcms4XeKBCHU0ZKnIkdJeU/kF+eRp5lBg==}
-    engines: {node: '>=6.9.0'}
-
-  '@bcoe/v8-coverage@1.0.2':
-    resolution: {integrity: sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==}
-    engines: {node: '>=18'}
-
   '@csstools/color-helpers@5.1.0':
     resolution: {integrity: sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==}
     engines: {node: '>=18'}
@@ -889,15 +869,6 @@ packages:
     resolution: {integrity: sha512-LZ2NqIHFhvFwxG0qZeLL9DvdNAHPGCY5dIRwBhyYeU+LfLhcStE1ImjsuTG/WaVh3XysGaeLW8Rqq7cGkPCFvw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@vitest/coverage-v8@4.0.18':
-    resolution: {integrity: sha512-7i+N2i0+ME+2JFZhfuz7Tg/FqKtilHjGyGvoHYQ6iLV0zahbsJ9sljC9OcFcPDbhYKCet+sG8SsVqlyGvPflZg==}
-    peerDependencies:
-      '@vitest/browser': 4.0.18
-      vitest: 4.0.18
-    peerDependenciesMeta:
-      '@vitest/browser':
-        optional: true
-
   '@vitest/expect@4.0.17':
     resolution: {integrity: sha512-mEoqP3RqhKlbmUmntNDDCJeTDavDR+fVYkSOw8qRwJFaW/0/5zA9zFeTrHqNtcmwh6j26yMmwx2PqUDPzt5ZAQ==}
 
@@ -915,9 +886,6 @@ packages:
   '@vitest/pretty-format@4.0.17':
     resolution: {integrity: sha512-Ah3VAYmjcEdHg6+MwFE17qyLqBHZ+ni2ScKCiW2XrlSBV4H3Z7vYfPfz7CWQ33gyu76oc0Ai36+kgLU3rfF4nw==}
 
-  '@vitest/pretty-format@4.0.18':
-    resolution: {integrity: sha512-P24GK3GulZWC5tz87ux0m8OADrQIUVDPIjjj65vBXYG17ZeU3qD7r+MNZ1RNv4l8CGU2vtTRqixrOi9fYk/yKw==}
-
   '@vitest/runner@4.0.17':
     resolution: {integrity: sha512-JmuQyf8aMWoo/LmNFppdpkfRVHJcsgzkbCA+/Bk7VfNH7RE6Ut2qxegeyx2j3ojtJtKIbIGy3h+KxGfYfk28YQ==}
 
@@ -930,9 +898,6 @@ packages:
   '@vitest/utils@4.0.17':
     resolution: {integrity: sha512-RG6iy+IzQpa9SB8HAFHJ9Y+pTzI+h8553MrciN9eC6TFBErqrQaTas4vG+MVj8S4uKk8uTT2p0vgZPnTdxd96w==}
 
-  '@vitest/utils@4.0.18':
-    resolution: {integrity: sha512-msMRKLMVLWygpK3u2Hybgi4MNjcYJvwTb0Ru09+fOyCXIgT5raYP041DRRdiJiI3k/2U6SEbAETB3YtBrUkCFA==}
-
   acorn-jsx@5.3.2:
     resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
     peerDependencies:
@@ -976,9 +941,6 @@ packages:
     resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
     engines: {node: '>=12'}
 
-  ast-v8-to-istanbul@0.3.10:
-    resolution: {integrity: sha512-p4K7vMz2ZSk3wN8l5o3y2bJAoZXT3VuJI5OLTATY/01CYWumWvwkUw0SqDBnNq6IiTO3qDa1eSQDibAV8g7XOQ==}
-
   axobject-query@4.1.0:
     resolution: {integrity: sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==}
     engines: {node: '>= 0.4'}
@@ -1249,9 +1211,6 @@ packages:
     resolution: {integrity: sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==}
     engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
 
-  html-escaper@2.0.2:
-    resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==}
-
   http-proxy-agent@7.0.2:
     resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==}
     engines: {node: '>= 14'}
@@ -1297,18 +1256,6 @@ packages:
   isexe@2.0.0:
     resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
 
-  istanbul-lib-coverage@3.2.2:
-    resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==}
-    engines: {node: '>=8'}
-
-  istanbul-lib-report@3.0.1:
-    resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==}
-    engines: {node: '>=10'}
-
-  istanbul-reports@3.2.0:
-    resolution: {integrity: sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==}
-    engines: {node: '>=8'}
-
   jiti@2.6.1:
     resolution: {integrity: sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==}
     hasBin: true
@@ -1316,9 +1263,6 @@ packages:
   js-tokens@4.0.0:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
 
-  js-tokens@9.0.1:
-    resolution: {integrity: sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==}
-
   js-yaml@4.1.1:
     resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==}
     hasBin: true
@@ -1450,13 +1394,6 @@ packages:
   magic-string@0.30.21:
     resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
 
-  magicast@0.5.1:
-    resolution: {integrity: sha512-xrHS24IxaLrvuo613F719wvOIv9xPHFWQHuvGUBmPnCA/3MQxKI3b+r7n1jAoDHmsbC5bRhTZYR77invLAxVnw==}
-
-  make-dir@4.0.0:
-    resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==}
-    engines: {node: '>=10'}
-
   marked@17.0.1:
     resolution: {integrity: sha512-boeBdiS0ghpWcSwoNm/jJBwdpFaMnZWRzjA6SkUMYb40SVaN1x7mmfGKp0jvexGcx+7y2La5zRZsYFZI6Qpypg==}
     engines: {node: '>= 20'}
@@ -1932,23 +1869,10 @@ snapshots:
       js-tokens: 4.0.0
       picocolors: 1.1.1
 
-  '@babel/helper-string-parser@7.27.1': {}
-
   '@babel/helper-validator-identifier@7.28.5': {}
 
-  '@babel/parser@7.28.6':
-    dependencies:
-      '@babel/types': 7.28.6
-
   '@babel/runtime@7.28.6': {}
 
-  '@babel/types@7.28.6':
-    dependencies:
-      '@babel/helper-string-parser': 7.27.1
-      '@babel/helper-validator-identifier': 7.28.5
-
-  '@bcoe/v8-coverage@1.0.2': {}
-
   '@csstools/color-helpers@5.1.0': {}
 
   '@csstools/css-calc@2.1.4(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)':
@@ -2545,20 +2469,6 @@ snapshots:
       '@typescript-eslint/types': 8.53.0
       eslint-visitor-keys: 4.2.1
 
-  '@vitest/coverage-v8@4.0.18(vitest@4.0.17(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2))':
-    dependencies:
-      '@bcoe/v8-coverage': 1.0.2
-      '@vitest/utils': 4.0.18
-      ast-v8-to-istanbul: 0.3.10
-      istanbul-lib-coverage: 3.2.2
-      istanbul-lib-report: 3.0.1
-      istanbul-reports: 3.2.0
-      magicast: 0.5.1
-      obug: 2.1.1
-      std-env: 3.10.0
-      tinyrainbow: 3.0.3
-      vitest: 4.0.17(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2)
-
   '@vitest/expect@4.0.17':
     dependencies:
       '@standard-schema/spec': 1.1.0
@@ -2580,10 +2490,6 @@ snapshots:
     dependencies:
       tinyrainbow: 3.0.3
 
-  '@vitest/pretty-format@4.0.18':
-    dependencies:
-      tinyrainbow: 3.0.3
-
   '@vitest/runner@4.0.17':
     dependencies:
       '@vitest/utils': 4.0.17
@@ -2602,11 +2508,6 @@ snapshots:
       '@vitest/pretty-format': 4.0.17
       tinyrainbow: 3.0.3
 
-  '@vitest/utils@4.0.18':
-    dependencies:
-      '@vitest/pretty-format': 4.0.18
-      tinyrainbow: 3.0.3
-
   acorn-jsx@5.3.2(acorn@8.15.0):
     dependencies:
       acorn: 8.15.0
@@ -2640,12 +2541,6 @@ snapshots:
 
   assertion-error@2.0.1: {}
 
-  ast-v8-to-istanbul@0.3.10:
-    dependencies:
-      '@jridgewell/trace-mapping': 0.3.31
-      estree-walker: 3.0.3
-      js-tokens: 9.0.1
-
   axobject-query@4.1.0: {}
 
   balanced-match@1.0.2: {}
@@ -2928,8 +2823,6 @@ snapshots:
     transitivePeerDependencies:
       - '@exodus/crypto'
 
-  html-escaper@2.0.2: {}
-
   http-proxy-agent@7.0.2:
     dependencies:
       agent-base: 7.1.4
@@ -2971,25 +2864,10 @@ snapshots:
 
   isexe@2.0.0: {}
 
-  istanbul-lib-coverage@3.2.2: {}
-
-  istanbul-lib-report@3.0.1:
-    dependencies:
-      istanbul-lib-coverage: 3.2.2
-      make-dir: 4.0.0
-      supports-color: 7.2.0
-
-  istanbul-reports@3.2.0:
-    dependencies:
-      html-escaper: 2.0.2
-      istanbul-lib-report: 3.0.1
-
   jiti@2.6.1: {}
 
   js-tokens@4.0.0: {}
 
-  js-tokens@9.0.1: {}
-
   js-yaml@4.1.1:
     dependencies:
       argparse: 2.0.1
@@ -3108,16 +2986,6 @@ snapshots:
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.5
 
-  magicast@0.5.1:
-    dependencies:
-      '@babel/parser': 7.28.6
-      '@babel/types': 7.28.6
-      source-map-js: 1.2.1
-
-  make-dir@4.0.0:
-    dependencies:
-      semver: 7.7.3
-
   marked@17.0.1: {}
 
   mdn-data@2.12.2: {}

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hikari-desktop"
-version = "1.0.0"
+version = "0.3.0"
 description = "Hikari - Claude Code Visual Assistant"
 authors = ["Naomi Carrigan"]
 edition = "2021"

src-tauri/src/clipboard.rs

@@ -257,468 +257,3 @@ pub fn update_clipboard_language(
     save_history(&app, &history)?;
     Ok(updated_entry)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    // ==================== ClipboardEntry tests ====================
-
-    #[test]
-    fn test_clipboard_entry_new() {
-        let entry = ClipboardEntry::new(
-            "let x = 42;".to_string(),
-            Some("rust".to_string()),
-            Some("main.rs".to_string()),
-        );
-
-        assert_eq!(entry.content, "let x = 42;");
-        assert_eq!(entry.language, Some("rust".to_string()));
-        assert_eq!(entry.source, Some("main.rs".to_string()));
-        assert!(!entry.is_pinned);
-        assert!(!entry.id.is_empty());
-        assert!(!entry.timestamp.is_empty());
-    }
-
-    #[test]
-    fn test_clipboard_entry_new_without_optional_fields() {
-        let entry = ClipboardEntry::new("some content".to_string(), None, None);
-
-        assert_eq!(entry.content, "some content");
-        assert!(entry.language.is_none());
-        assert!(entry.source.is_none());
-        assert!(!entry.is_pinned);
-    }
-
-    #[test]
-    fn test_clipboard_entry_unique_ids() {
-        let entry1 = ClipboardEntry::new("content1".to_string(), None, None);
-        let entry2 = ClipboardEntry::new("content2".to_string(), None, None);
-
-        assert_ne!(entry1.id, entry2.id);
-    }
-
-    #[test]
-    fn test_clipboard_entry_serialization() {
-        let entry = ClipboardEntry::new(
-            "fn main() {}".to_string(),
-            Some("rust".to_string()),
-            Some("lib.rs".to_string()),
-        );
-
-        let json = serde_json::to_string(&entry).unwrap();
-        assert!(json.contains("fn main() {}"));
-        assert!(json.contains("rust"));
-        assert!(json.contains("lib.rs"));
-        assert!(json.contains("is_pinned"));
-
-        let deserialized: ClipboardEntry = serde_json::from_str(&json).unwrap();
-        assert_eq!(deserialized.content, entry.content);
-        assert_eq!(deserialized.language, entry.language);
-        assert_eq!(deserialized.source, entry.source);
-        assert_eq!(deserialized.id, entry.id);
-    }
-
-    #[test]
-    fn test_clipboard_entry_clone() {
-        let entry = ClipboardEntry::new(
-            "original".to_string(),
-            Some("python".to_string()),
-            None,
-        );
-
-        let cloned = entry.clone();
-        assert_eq!(cloned.content, entry.content);
-        assert_eq!(cloned.id, entry.id);
-        assert_eq!(cloned.language, entry.language);
-    }
-
-    #[test]
-    fn test_clipboard_entry_timestamp_is_rfc3339() {
-        let entry = ClipboardEntry::new("test".to_string(), None, None);
-
-        // RFC3339 timestamp should parse successfully
-        let parsed = chrono::DateTime::parse_from_rfc3339(&entry.timestamp);
-        assert!(parsed.is_ok());
-    }
-
-    // ==================== ClipboardHistory tests ====================
-
-    #[test]
-    fn test_clipboard_history_default() {
-        let history = ClipboardHistory::default();
-        assert!(history.entries.is_empty());
-    }
-
-    #[test]
-    fn test_clipboard_history_serialization() {
-        let mut history = ClipboardHistory::default();
-        history.entries.push(ClipboardEntry::new(
-            "entry1".to_string(),
-            Some("js".to_string()),
-            None,
-        ));
-        history.entries.push(ClipboardEntry::new(
-            "entry2".to_string(),
-            None,
-            Some("file.txt".to_string()),
-        ));
-
-        let json = serde_json::to_string(&history).unwrap();
-        assert!(json.contains("entry1"));
-        assert!(json.contains("entry2"));
-        assert!(json.contains("js"));
-        assert!(json.contains("file.txt"));
-
-        let deserialized: ClipboardHistory = serde_json::from_str(&json).unwrap();
-        assert_eq!(deserialized.entries.len(), 2);
-    }
-
-    #[test]
-    fn test_clipboard_history_entries_order() {
-        let mut history = ClipboardHistory::default();
-
-        history.entries.push(ClipboardEntry::new("first".to_string(), None, None));
-        history.entries.push(ClipboardEntry::new("second".to_string(), None, None));
-        history.entries.push(ClipboardEntry::new("third".to_string(), None, None));
-
-        assert_eq!(history.entries[0].content, "first");
-        assert_eq!(history.entries[1].content, "second");
-        assert_eq!(history.entries[2].content, "third");
-    }
-
-    // ==================== ClipboardState tests ====================
-
-    #[test]
-    fn test_clipboard_state_default() {
-        let state = ClipboardState::default();
-        assert!(state.last_content.is_none());
-    }
-
-    #[test]
-    fn test_clipboard_state_with_content() {
-        let state = ClipboardState {
-            last_content: Some("cached content".to_string()),
-        };
-        assert_eq!(state.last_content, Some("cached content".to_string()));
-    }
-
-    // ==================== MAX_HISTORY_SIZE constant test ====================
-
-    #[test]
-    fn test_max_history_size_is_reasonable() {
-        assert_eq!(MAX_HISTORY_SIZE, 100);
-        // Compile-time assertions for constant bounds
-        const _: () = assert!(MAX_HISTORY_SIZE > 0);
-        const _: () = assert!(MAX_HISTORY_SIZE <= 1000); // Sanity check
-    }
-
-    // ==================== Pinned entry sorting tests ====================
-
-    #[test]
-    #[allow(clippy::useless_vec)]
-    fn test_pinned_entries_sorting() {
-        let mut entries = vec![
-            ClipboardEntry {
-                id: "1".to_string(),
-                content: "unpinned older".to_string(),
-                language: None,
-                source: None,
-                timestamp: "2024-01-01T00:00:00Z".to_string(),
-                is_pinned: false,
-            },
-            ClipboardEntry {
-                id: "2".to_string(),
-                content: "pinned".to_string(),
-                language: None,
-                source: None,
-                timestamp: "2024-01-02T00:00:00Z".to_string(),
-                is_pinned: true,
-            },
-            ClipboardEntry {
-                id: "3".to_string(),
-                content: "unpinned newer".to_string(),
-                language: None,
-                source: None,
-                timestamp: "2024-01-03T00:00:00Z".to_string(),
-                is_pinned: false,
-            },
-        ];
-
-        // Apply the same sorting logic as used in the module
-        entries.sort_by(|a, b| {
-            if a.is_pinned && !b.is_pinned {
-                std::cmp::Ordering::Less
-            } else if !a.is_pinned && b.is_pinned {
-                std::cmp::Ordering::Greater
-            } else {
-                b.timestamp.cmp(&a.timestamp)
-            }
-        });
-
-        // Pinned should be first
-        assert!(entries[0].is_pinned);
-        assert_eq!(entries[0].id, "2");
-
-        // Then unpinned sorted by timestamp descending (newest first)
-        assert_eq!(entries[1].id, "3"); // newer unpinned
-        assert_eq!(entries[2].id, "1"); // older unpinned
-    }
-
-    #[test]
-    #[allow(clippy::useless_vec)]
-    fn test_multiple_pinned_entries_sorting() {
-        let mut entries = vec![
-            ClipboardEntry {
-                id: "1".to_string(),
-                content: "pinned older".to_string(),
-                language: None,
-                source: None,
-                timestamp: "2024-01-01T00:00:00Z".to_string(),
-                is_pinned: true,
-            },
-            ClipboardEntry {
-                id: "2".to_string(),
-                content: "unpinned".to_string(),
-                language: None,
-                source: None,
-                timestamp: "2024-01-02T00:00:00Z".to_string(),
-                is_pinned: false,
-            },
-            ClipboardEntry {
-                id: "3".to_string(),
-                content: "pinned newer".to_string(),
-                language: None,
-                source: None,
-                timestamp: "2024-01-03T00:00:00Z".to_string(),
-                is_pinned: true,
-            },
-        ];
-
-        entries.sort_by(|a, b| {
-            if a.is_pinned && !b.is_pinned {
-                std::cmp::Ordering::Less
-            } else if !a.is_pinned && b.is_pinned {
-                std::cmp::Ordering::Greater
-            } else {
-                b.timestamp.cmp(&a.timestamp)
-            }
-        });
-
-        // Both pinned first, sorted by timestamp
-        assert!(entries[0].is_pinned);
-        assert_eq!(entries[0].id, "3"); // pinned newer
-        assert!(entries[1].is_pinned);
-        assert_eq!(entries[1].id, "1"); // pinned older
-        // Then unpinned
-        assert!(!entries[2].is_pinned);
-        assert_eq!(entries[2].id, "2");
-    }
-
-    // ==================== Entry filtering tests ====================
-
-    #[test]
-    fn test_filter_entries_by_language() {
-        let history = ClipboardHistory {
-            entries: vec![
-                ClipboardEntry {
-                    id: "1".to_string(),
-                    content: "rust code".to_string(),
-                    language: Some("rust".to_string()),
-                    source: None,
-                    timestamp: "2024-01-01T00:00:00Z".to_string(),
-                    is_pinned: false,
-                },
-                ClipboardEntry {
-                    id: "2".to_string(),
-                    content: "js code".to_string(),
-                    language: Some("javascript".to_string()),
-                    source: None,
-                    timestamp: "2024-01-02T00:00:00Z".to_string(),
-                    is_pinned: false,
-                },
-                ClipboardEntry {
-                    id: "3".to_string(),
-                    content: "more rust".to_string(),
-                    language: Some("rust".to_string()),
-                    source: None,
-                    timestamp: "2024-01-03T00:00:00Z".to_string(),
-                    is_pinned: false,
-                },
-            ],
-        };
-
-        let filtered: Vec<_> = history
-            .entries
-            .iter()
-            .filter(|e| e.language.as_ref() == Some(&"rust".to_string()))
-            .collect();
-
-        assert_eq!(filtered.len(), 2);
-        assert!(filtered.iter().all(|e| e.language == Some("rust".to_string())));
-    }
-
-    #[test]
-    fn test_search_entries_by_content() {
-        let history = ClipboardHistory {
-            entries: vec![
-                ClipboardEntry {
-                    id: "1".to_string(),
-                    content: "fn hello_world()".to_string(),
-                    language: Some("rust".to_string()),
-                    source: None,
-                    timestamp: "2024-01-01T00:00:00Z".to_string(),
-                    is_pinned: false,
-                },
-                ClipboardEntry {
-                    id: "2".to_string(),
-                    content: "function hello()".to_string(),
-                    language: Some("javascript".to_string()),
-                    source: None,
-                    timestamp: "2024-01-02T00:00:00Z".to_string(),
-                    is_pinned: false,
-                },
-                ClipboardEntry {
-                    id: "3".to_string(),
-                    content: "def goodbye()".to_string(),
-                    language: Some("python".to_string()),
-                    source: None,
-                    timestamp: "2024-01-03T00:00:00Z".to_string(),
-                    is_pinned: false,
-                },
-            ],
-        };
-
-        let query = "hello";
-        let query_lower = query.to_lowercase();
-        let filtered: Vec<_> = history
-            .entries
-            .iter()
-            .filter(|e| e.content.to_lowercase().contains(&query_lower))
-            .collect();
-
-        assert_eq!(filtered.len(), 2);
-        assert!(filtered[0].content.contains("hello"));
-        assert!(filtered[1].content.contains("hello"));
-    }
-
-    #[test]
-    fn test_search_entries_case_insensitive() {
-        let history = ClipboardHistory {
-            entries: vec![
-                ClipboardEntry {
-                    id: "1".to_string(),
-                    content: "HELLO WORLD".to_string(),
-                    language: None,
-                    source: None,
-                    timestamp: "2024-01-01T00:00:00Z".to_string(),
-                    is_pinned: false,
-                },
-            ],
-        };
-
-        let query = "hello";
-        let query_lower = query.to_lowercase();
-        let filtered: Vec<_> = history
-            .entries
-            .iter()
-            .filter(|e| e.content.to_lowercase().contains(&query_lower))
-            .collect();
-
-        assert_eq!(filtered.len(), 1);
-    }
-
-    // ==================== Unique languages extraction test ====================
-
-    #[test]
-    fn test_extract_unique_languages() {
-        let history = ClipboardHistory {
-            entries: vec![
-                ClipboardEntry {
-                    id: "1".to_string(),
-                    content: "".to_string(),
-                    language: Some("rust".to_string()),
-                    source: None,
-                    timestamp: "".to_string(),
-                    is_pinned: false,
-                },
-                ClipboardEntry {
-                    id: "2".to_string(),
-                    content: "".to_string(),
-                    language: Some("javascript".to_string()),
-                    source: None,
-                    timestamp: "".to_string(),
-                    is_pinned: false,
-                },
-                ClipboardEntry {
-                    id: "3".to_string(),
-                    content: "".to_string(),
-                    language: Some("rust".to_string()), // Duplicate
-                    source: None,
-                    timestamp: "".to_string(),
-                    is_pinned: false,
-                },
-                ClipboardEntry {
-                    id: "4".to_string(),
-                    content: "".to_string(),
-                    language: None, // No language
-                    source: None,
-                    timestamp: "".to_string(),
-                    is_pinned: false,
-                },
-            ],
-        };
-
-        let mut languages: Vec<String> = history
-            .entries
-            .iter()
-            .filter_map(|e| e.language.clone())
-            .collect();
-        languages.sort();
-        languages.dedup();
-
-        assert_eq!(languages.len(), 2);
-        assert!(languages.contains(&"rust".to_string()));
-        assert!(languages.contains(&"javascript".to_string()));
-    }
-
-    // ==================== Retain pinned entries test ====================
-
-    #[test]
-    fn test_retain_pinned_on_clear() {
-        let mut history = ClipboardHistory {
-            entries: vec![
-                ClipboardEntry {
-                    id: "1".to_string(),
-                    content: "pinned".to_string(),
-                    language: None,
-                    source: None,
-                    timestamp: "".to_string(),
-                    is_pinned: true,
-                },
-                ClipboardEntry {
-                    id: "2".to_string(),
-                    content: "unpinned".to_string(),
-                    language: None,
-                    source: None,
-                    timestamp: "".to_string(),
-                    is_pinned: false,
-                },
-                ClipboardEntry {
-                    id: "3".to_string(),
-                    content: "another pinned".to_string(),
-                    language: None,
-                    source: None,
-                    timestamp: "".to_string(),
-                    is_pinned: true,
-                },
-            ],
-        };
-
-        // Simulate clear (keep only pinned)
-        history.entries.retain(|e| e.is_pinned);
-
-        assert_eq!(history.entries.len(), 2);
-        assert!(history.entries.iter().all(|e| e.is_pinned));
-    }
-}

src-tauri/src/commands.rs

@@ -393,263 +393,3 @@ pub async fn get_file_size(file_path: String) -> Result<u64, String> {
         .map_err(|e| format!("Failed to get file metadata: {}", e))?;
     Ok(metadata.len())
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::fs::{self, File};
-    use std::io::Write;
-    use tempfile::TempDir;
-
-    // Helper to run async tests
-    fn run_async<F: std::future::Future>(f: F) -> F::Output {
-        tokio::runtime::Runtime::new().unwrap().block_on(f)
-    }
-
-    // ==================== validate_directory tests ====================
-
-    #[test]
-    fn test_validate_directory_absolute_path_exists() {
-        let temp_dir = TempDir::new().unwrap();
-        let path = temp_dir.path().to_string_lossy().to_string();
-
-        let result = run_async(validate_directory(path.clone(), None));
-        assert!(result.is_ok());
-        // Canonicalized path should be returned
-        assert!(result.unwrap().contains(&temp_dir.path().file_name().unwrap().to_string_lossy().to_string()));
-    }
-
-    #[test]
-    fn test_validate_directory_path_not_exists() {
-        let result = run_async(validate_directory(
-            "/nonexistent/path/that/does/not/exist".to_string(),
-            None,
-        ));
-        assert!(result.is_err());
-        assert!(result.unwrap_err().contains("does not exist"));
-    }
-
-    #[test]
-    fn test_validate_directory_path_is_file() {
-        let temp_dir = TempDir::new().unwrap();
-        let file_path = temp_dir.path().join("test_file.txt");
-        File::create(&file_path).unwrap();
-
-        let result = run_async(validate_directory(
-            file_path.to_string_lossy().to_string(),
-            None,
-        ));
-        assert!(result.is_err());
-        assert!(result.unwrap_err().contains("not a directory"));
-    }
-
-    #[test]
-    fn test_validate_directory_home_expansion() {
-        // This test assumes HOME is set (which it should be on most systems)
-        if std::env::var_os("HOME").is_some() {
-            let result = run_async(validate_directory("~".to_string(), None));
-            assert!(result.is_ok());
-            // Should not contain ~ after expansion
-            assert!(!result.unwrap().contains("~"));
-        }
-    }
-
-    #[test]
-    fn test_validate_directory_home_subpath_expansion() {
-        // This test assumes HOME is set and has some subdirectory
-        if let Some(home) = std::env::var_os("HOME") {
-            let home_path = std::path::Path::new(&home);
-            // Find any subdirectory in home
-            if let Ok(entries) = fs::read_dir(home_path) {
-                for entry in entries.flatten() {
-                    if entry.path().is_dir() {
-                        let subdir_name = entry.file_name().to_string_lossy().to_string();
-                        let tilde_path = format!("~/{}", subdir_name);
-                        let result = run_async(validate_directory(tilde_path, None));
-                        assert!(result.is_ok());
-                        assert!(!result.unwrap().contains("~"));
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn test_validate_directory_relative_path_with_current_dir() {
-        let temp_dir = TempDir::new().unwrap();
-        let subdir = temp_dir.path().join("subdir");
-        fs::create_dir(&subdir).unwrap();
-
-        let result = run_async(validate_directory(
-            "subdir".to_string(),
-            Some(temp_dir.path().to_string_lossy().to_string()),
-        ));
-        assert!(result.is_ok());
-        assert!(result.unwrap().contains("subdir"));
-    }
-
-    #[test]
-    fn test_validate_directory_dot_path() {
-        let temp_dir = TempDir::new().unwrap();
-
-        let result = run_async(validate_directory(
-            ".".to_string(),
-            Some(temp_dir.path().to_string_lossy().to_string()),
-        ));
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_validate_directory_dotdot_path() {
-        let temp_dir = TempDir::new().unwrap();
-        let subdir = temp_dir.path().join("subdir");
-        fs::create_dir(&subdir).unwrap();
-
-        let result = run_async(validate_directory(
-            "..".to_string(),
-            Some(subdir.to_string_lossy().to_string()),
-        ));
-        assert!(result.is_ok());
-        // Should resolve to parent
-        let resolved = result.unwrap();
-        assert!(resolved.contains(&temp_dir.path().file_name().unwrap().to_string_lossy().to_string()));
-    }
-
-    #[test]
-    fn test_validate_directory_relative_without_current_dir() {
-        // Relative path without current_dir - should fail since relative path likely won't exist
-        let result = run_async(validate_directory(
-            "some_random_nonexistent_relative_path".to_string(),
-            None,
-        ));
-        assert!(result.is_err());
-    }
-
-    // ==================== get_file_size tests ====================
-
-    #[test]
-    fn test_get_file_size_empty_file() {
-        let temp_dir = TempDir::new().unwrap();
-        let file_path = temp_dir.path().join("empty.txt");
-        File::create(&file_path).unwrap();
-
-        let result = run_async(get_file_size(file_path.to_string_lossy().to_string()));
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 0);
-    }
-
-    #[test]
-    fn test_get_file_size_with_content() {
-        let temp_dir = TempDir::new().unwrap();
-        let file_path = temp_dir.path().join("content.txt");
-        let mut file = File::create(&file_path).unwrap();
-        file.write_all(b"Hello, Hikari!").unwrap();
-
-        let result = run_async(get_file_size(file_path.to_string_lossy().to_string()));
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 14); // "Hello, Hikari!" is 14 bytes
-    }
-
-    #[test]
-    fn test_get_file_size_larger_file() {
-        let temp_dir = TempDir::new().unwrap();
-        let file_path = temp_dir.path().join("large.txt");
-        let mut file = File::create(&file_path).unwrap();
-        // Write 1000 bytes
-        let data = vec![b'x'; 1000];
-        file.write_all(&data).unwrap();
-
-        let result = run_async(get_file_size(file_path.to_string_lossy().to_string()));
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 1000);
-    }
-
-    #[test]
-    fn test_get_file_size_nonexistent_file() {
-        let result = run_async(get_file_size(
-            "/nonexistent/path/file.txt".to_string(),
-        ));
-        assert!(result.is_err());
-        assert!(result.unwrap_err().contains("Failed to get file metadata"));
-    }
-
-    #[test]
-    fn test_get_file_size_directory() {
-        let temp_dir = TempDir::new().unwrap();
-
-        // Getting "size" of a directory should work but return directory metadata
-        // This is actually valid - directories have metadata too
-        let result = run_async(get_file_size(temp_dir.path().to_string_lossy().to_string()));
-        assert!(result.is_ok());
-        // Directory size is platform-dependent, just check it returns something
-    }
-
-    // ==================== list_skills tests ====================
-
-    #[test]
-    fn test_list_skills_no_skills_dir() {
-        // This test is tricky because it depends on HOME being set
-        // and potentially affecting real user data, so we'll just
-        // verify the function doesn't panic
-        let result = run_async(list_skills());
-        // Should either return Ok with a list or Ok with empty vec
-        assert!(result.is_ok());
-    }
-
-    // ==================== select_wsl_directory tests ====================
-
-    #[test]
-    fn test_select_wsl_directory_returns_home() {
-        let result = run_async(select_wsl_directory());
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), "/home");
-    }
-
-    // ==================== UpdateInfo struct tests ====================
-
-    #[test]
-    fn test_update_info_serialization() {
-        let info = UpdateInfo {
-            current_version: "1.0.0".to_string(),
-            latest_version: "0.4.0".to_string(),
-            has_update: true,
-            release_url: "https://example.com/release".to_string(),
-            release_notes: Some("New features!".to_string()),
-        };
-
-        let json = serde_json::to_string(&info).unwrap();
-        assert!(json.contains("1.0.0"));
-        assert!(json.contains("0.4.0"));
-        assert!(json.contains("true"));
-        assert!(json.contains("New features!"));
-    }
-
-    #[test]
-    fn test_update_info_without_notes() {
-        let info = UpdateInfo {
-            current_version: "1.0.0".to_string(),
-            latest_version: "1.0.0".to_string(),
-            has_update: false,
-            release_url: "https://example.com/release".to_string(),
-            release_notes: None,
-        };
-
-        let json = serde_json::to_string(&info).unwrap();
-        assert!(json.contains("null") || json.contains("release_notes"));
-    }
-
-    // ==================== SavedFileInfo struct tests ====================
-
-    #[test]
-    fn test_saved_file_info_serialization() {
-        let info = SavedFileInfo {
-            path: "/tmp/test.txt".to_string(),
-            filename: "test.txt".to_string(),
-        };
-
-        let json = serde_json::to_string(&info).unwrap();
-        assert!(json.contains("/tmp/test.txt"));
-        assert!(json.contains("test.txt"));
-    }
-}

src-tauri/src/config.rs

@@ -92,10 +92,6 @@ pub struct HikariConfig {
 
     #[serde(default)]
     pub profile_bio: Option<String>,
-
-    // Custom theme colors
-    #[serde(default)]
-    pub custom_theme_colors: CustomThemeColors,
 }
 
 impl Default for HikariConfig {
@@ -122,7 +118,6 @@ impl Default for HikariConfig {
             profile_name: None,
             profile_avatar_path: None,
             profile_bio: None,
-            custom_theme_colors: CustomThemeColors::default(),
         }
     }
 }
@@ -155,27 +150,6 @@ pub enum Theme {
     Light,
     #[serde(rename = "high-contrast")]
     HighContrast,
-    Custom,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
-pub struct CustomThemeColors {
-    #[serde(default)]
-    pub bg_primary: Option<String>,
-    #[serde(default)]
-    pub bg_secondary: Option<String>,
-    #[serde(default)]
-    pub bg_terminal: Option<String>,
-    #[serde(default)]
-    pub accent_primary: Option<String>,
-    #[serde(default)]
-    pub accent_secondary: Option<String>,
-    #[serde(default)]
-    pub text_primary: Option<String>,
-    #[serde(default)]
-    pub text_secondary: Option<String>,
-    #[serde(default)]
-    pub border_color: Option<String>,
 }
 
 #[cfg(test)]
@@ -204,7 +178,6 @@ mod tests {
         assert!(config.profile_name.is_none());
         assert!(config.profile_avatar_path.is_none());
         assert!(config.profile_bio.is_none());
-        assert_eq!(config.custom_theme_colors, CustomThemeColors::default());
     }
 
     #[test]
@@ -231,7 +204,6 @@ mod tests {
             profile_name: Some("Test User".to_string()),
             profile_avatar_path: None,
             profile_bio: Some("A test bio".to_string()),
-            custom_theme_colors: CustomThemeColors::default(),
         };
 
         let json = serde_json::to_string(&config).unwrap();
@@ -260,8 +232,5 @@ mod tests {
             serde_json::to_string(&high_contrast).unwrap(),
             "\"high-contrast\""
         );
-
-        let custom = Theme::Custom;
-        assert_eq!(serde_json::to_string(&custom).unwrap(), "\"custom\"");
     }
 }

src-tauri/src/git.rs

@@ -286,593 +286,3 @@ pub fn git_discard(working_dir: String, file_path: String) -> Result<String, Str
 pub fn git_create_branch(working_dir: String, branch_name: String) -> Result<String, String> {
     run_git_command(&working_dir, &["checkout", "-b", &branch_name])
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::fs::{self, File};
-    use std::io::Write;
-    use tempfile::TempDir;
-
-    // Helper to create a git repository in a temp directory
-    fn create_test_repo() -> TempDir {
-        let temp_dir = TempDir::new().unwrap();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Initialize git repo
-        run_git_command(&working_dir, &["init"]).unwrap();
-
-        // Configure git user for commits
-        run_git_command(&working_dir, &["config", "user.email", "test@example.com"]).unwrap();
-        run_git_command(&working_dir, &["config", "user.name", "Test User"]).unwrap();
-
-        // Disable GPG signing for tests (user may have it enabled globally)
-        run_git_command(&working_dir, &["config", "commit.gpgsign", "false"]).unwrap();
-
-        temp_dir
-    }
-
-    // Helper to create a file in the test repo
-    fn create_file(dir: &TempDir, name: &str, content: &str) {
-        let file_path = dir.path().join(name);
-        let mut file = File::create(file_path).unwrap();
-        file.write_all(content.as_bytes()).unwrap();
-    }
-
-    // ==================== GitStatus struct tests ====================
-
-    #[test]
-    fn test_git_status_serialization() {
-        let status = GitStatus {
-            is_repo: true,
-            branch: Some("main".to_string()),
-            upstream: Some("origin/main".to_string()),
-            ahead: 2,
-            behind: 1,
-            staged: vec![GitFileChange {
-                path: "file.txt".to_string(),
-                status: "modified".to_string(),
-            }],
-            unstaged: vec![],
-            untracked: vec!["new_file.txt".to_string()],
-        };
-
-        let json = serde_json::to_string(&status).unwrap();
-        assert!(json.contains("\"is_repo\":true"));
-        assert!(json.contains("\"branch\":\"main\""));
-        assert!(json.contains("\"ahead\":2"));
-        assert!(json.contains("\"behind\":1"));
-    }
-
-    #[test]
-    fn test_git_status_not_a_repo() {
-        let status = GitStatus {
-            is_repo: false,
-            branch: None,
-            upstream: None,
-            ahead: 0,
-            behind: 0,
-            staged: vec![],
-            unstaged: vec![],
-            untracked: vec![],
-        };
-
-        let json = serde_json::to_string(&status).unwrap();
-        let deserialized: GitStatus = serde_json::from_str(&json).unwrap();
-        assert!(!deserialized.is_repo);
-        assert!(deserialized.branch.is_none());
-    }
-
-    // ==================== GitFileChange struct tests ====================
-
-    #[test]
-    fn test_git_file_change_serialization() {
-        let change = GitFileChange {
-            path: "src/main.rs".to_string(),
-            status: "added".to_string(),
-        };
-
-        let json = serde_json::to_string(&change).unwrap();
-        assert!(json.contains("src/main.rs"));
-        assert!(json.contains("added"));
-
-        let deserialized: GitFileChange = serde_json::from_str(&json).unwrap();
-        assert_eq!(deserialized.path, "src/main.rs");
-        assert_eq!(deserialized.status, "added");
-    }
-
-    // ==================== GitBranch struct tests ====================
-
-    #[test]
-    fn test_git_branch_serialization() {
-        let branch = GitBranch {
-            name: "feature/new-feature".to_string(),
-            is_current: true,
-            is_remote: false,
-        };
-
-        let json = serde_json::to_string(&branch).unwrap();
-        assert!(json.contains("feature/new-feature"));
-        assert!(json.contains("\"is_current\":true"));
-        assert!(json.contains("\"is_remote\":false"));
-    }
-
-    #[test]
-    fn test_git_branch_remote() {
-        let branch = GitBranch {
-            name: "origin/main".to_string(),
-            is_current: false,
-            is_remote: true,
-        };
-
-        let json = serde_json::to_string(&branch).unwrap();
-        let deserialized: GitBranch = serde_json::from_str(&json).unwrap();
-        assert!(deserialized.is_remote);
-        assert!(!deserialized.is_current);
-    }
-
-    // ==================== GitLogEntry struct tests ====================
-
-    #[test]
-    fn test_git_log_entry_serialization() {
-        let entry = GitLogEntry {
-            hash: "abc123def456".to_string(),
-            short_hash: "abc123d".to_string(),
-            author: "Hikari".to_string(),
-            date: "2 hours ago".to_string(),
-            message: "feat: add new feature".to_string(),
-        };
-
-        let json = serde_json::to_string(&entry).unwrap();
-        assert!(json.contains("abc123def456"));
-        assert!(json.contains("Hikari"));
-        assert!(json.contains("feat: add new feature"));
-    }
-
-    // ==================== git_status integration tests ====================
-
-    #[test]
-    fn test_git_status_not_a_git_repo() {
-        let temp_dir = TempDir::new().unwrap();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        let result = git_status(working_dir);
-        assert!(result.is_ok());
-
-        let status = result.unwrap();
-        assert!(!status.is_repo);
-        assert!(status.branch.is_none());
-        assert!(status.staged.is_empty());
-    }
-
-    #[test]
-    fn test_git_status_empty_repo() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        let result = git_status(working_dir);
-        assert!(result.is_ok());
-
-        let status = result.unwrap();
-        assert!(status.is_repo);
-        assert!(status.staged.is_empty());
-        assert!(status.unstaged.is_empty());
-        assert!(status.untracked.is_empty());
-    }
-
-    #[test]
-    fn test_git_status_with_untracked_file() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Create an untracked file
-        create_file(&temp_dir, "untracked.txt", "hello");
-
-        let result = git_status(working_dir);
-        assert!(result.is_ok());
-
-        let status = result.unwrap();
-        assert!(status.is_repo);
-        assert!(status.untracked.contains(&"untracked.txt".to_string()));
-    }
-
-    #[test]
-    fn test_git_status_with_staged_file() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Create and stage a file
-        create_file(&temp_dir, "staged.txt", "hello");
-        run_git_command(&working_dir, &["add", "staged.txt"]).unwrap();
-
-        let result = git_status(working_dir);
-        assert!(result.is_ok());
-
-        let status = result.unwrap();
-        assert!(status.is_repo);
-        assert!(!status.staged.is_empty());
-        assert_eq!(status.staged[0].path, "staged.txt");
-        assert_eq!(status.staged[0].status, "added");
-    }
-
-    #[test]
-    fn test_git_status_with_modified_file() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Create, stage, and commit a file
-        create_file(&temp_dir, "file.txt", "initial content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial commit"]).unwrap();
-
-        // Modify the file
-        create_file(&temp_dir, "file.txt", "modified content");
-
-        let result = git_status(working_dir);
-        assert!(result.is_ok());
-
-        let status = result.unwrap();
-        assert!(status.is_repo);
-        assert!(!status.unstaged.is_empty());
-        assert_eq!(status.unstaged[0].path, "file.txt");
-        assert_eq!(status.unstaged[0].status, "modified");
-    }
-
-    // ==================== git_diff integration tests ====================
-
-    #[test]
-    fn test_git_diff_no_changes() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        let result = git_diff(working_dir, None, false);
-        assert!(result.is_ok());
-        assert!(result.unwrap().is_empty());
-    }
-
-    #[test]
-    fn test_git_diff_with_changes() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Create and commit a file
-        create_file(&temp_dir, "file.txt", "initial content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        // Modify the file
-        create_file(&temp_dir, "file.txt", "modified content");
-
-        let result = git_diff(working_dir, None, false);
-        assert!(result.is_ok());
-        let diff = result.unwrap();
-        assert!(diff.contains("diff"));
-        assert!(diff.contains("file.txt"));
-    }
-
-    #[test]
-    fn test_git_diff_staged() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Create and commit a file
-        create_file(&temp_dir, "file.txt", "initial content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        // Modify and stage the file
-        create_file(&temp_dir, "file.txt", "modified content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-
-        let result = git_diff(working_dir, None, true);
-        assert!(result.is_ok());
-        let diff = result.unwrap();
-        assert!(diff.contains("diff"));
-    }
-
-    #[test]
-    fn test_git_diff_specific_file() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Create and commit files
-        create_file(&temp_dir, "file1.txt", "content1");
-        create_file(&temp_dir, "file2.txt", "content2");
-        run_git_command(&working_dir, &["add", "-A"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        // Modify both files
-        create_file(&temp_dir, "file1.txt", "modified1");
-        create_file(&temp_dir, "file2.txt", "modified2");
-
-        // Get diff for only file1.txt
-        let result = git_diff(working_dir, Some("file1.txt".to_string()), false);
-        assert!(result.is_ok());
-        let diff = result.unwrap();
-        assert!(diff.contains("file1.txt"));
-        assert!(!diff.contains("file2.txt"));
-    }
-
-    // ==================== git_branches integration tests ====================
-
-    #[test]
-    fn test_git_branches_single_branch() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Need at least one commit for branches to show
-        create_file(&temp_dir, "file.txt", "content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        let result = git_branches(working_dir);
-        assert!(result.is_ok());
-
-        let branches = result.unwrap();
-        assert!(!branches.is_empty());
-        // Should have at least one branch (main or master)
-    }
-
-    #[test]
-    fn test_git_branches_multiple_branches() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Initial commit
-        create_file(&temp_dir, "file.txt", "content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        // Create additional branch
-        run_git_command(&working_dir, &["branch", "feature-branch"]).unwrap();
-
-        let result = git_branches(working_dir);
-        assert!(result.is_ok());
-
-        let branches = result.unwrap();
-        assert!(branches.len() >= 2);
-        assert!(branches.iter().any(|b| b.name == "feature-branch"));
-    }
-
-    // ==================== git_stage and git_unstage tests ====================
-
-    #[test]
-    fn test_git_stage_file() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        create_file(&temp_dir, "file.txt", "content");
-
-        let result = git_stage(working_dir.clone(), "file.txt".to_string());
-        assert!(result.is_ok());
-
-        // Verify file is staged
-        let status = git_status(working_dir).unwrap();
-        assert!(status.staged.iter().any(|f| f.path == "file.txt"));
-    }
-
-    #[test]
-    fn test_git_unstage_file() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // First, commit a file so we have a HEAD to restore from
-        create_file(&temp_dir, "file.txt", "initial content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        // Modify and stage the file
-        create_file(&temp_dir, "file.txt", "modified content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-
-        let result = git_unstage(working_dir.clone(), "file.txt".to_string());
-        assert!(result.is_ok());
-
-        // Verify file is unstaged (should now be in unstaged/modified, not staged)
-        let status = git_status(working_dir).unwrap();
-        assert!(!status.staged.iter().any(|f| f.path == "file.txt"));
-        assert!(status.unstaged.iter().any(|f| f.path == "file.txt"));
-    }
-
-    #[test]
-    fn test_git_stage_all() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        create_file(&temp_dir, "file1.txt", "content1");
-        create_file(&temp_dir, "file2.txt", "content2");
-
-        let result = git_stage_all(working_dir.clone());
-        assert!(result.is_ok());
-
-        // Verify all files are staged
-        let status = git_status(working_dir).unwrap();
-        assert_eq!(status.staged.len(), 2);
-    }
-
-    // ==================== git_commit tests ====================
-
-    #[test]
-    fn test_git_commit() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        create_file(&temp_dir, "file.txt", "content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-
-        let result = git_commit(working_dir.clone(), "test commit message".to_string());
-        assert!(result.is_ok());
-
-        // Verify commit was made
-        let log = git_log(working_dir, Some(1)).unwrap();
-        assert!(!log.is_empty());
-        assert!(log[0].message.contains("test commit message"));
-    }
-
-    #[test]
-    fn test_git_commit_nothing_to_commit() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Need initial commit first
-        create_file(&temp_dir, "file.txt", "content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        // Try to commit with nothing staged
-        let result = git_commit(working_dir, "empty commit".to_string());
-        assert!(result.is_err()); // Should fail because nothing to commit
-    }
-
-    // ==================== git_log tests ====================
-
-    #[test]
-    fn test_git_log_empty_repo() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        let result = git_log(working_dir, Some(10));
-        // May fail on empty repo or return empty
-        if let Ok(commits) = result {
-            assert!(commits.is_empty());
-        }
-    }
-
-    #[test]
-    fn test_git_log_with_commits() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Make multiple commits
-        for i in 1..=3 {
-            create_file(&temp_dir, &format!("file{}.txt", i), "content");
-            run_git_command(&working_dir, &["add", "-A"]).unwrap();
-            run_git_command(&working_dir, &["commit", "-m", &format!("commit {}", i)]).unwrap();
-        }
-
-        let result = git_log(working_dir, Some(10));
-        assert!(result.is_ok());
-
-        let log = result.unwrap();
-        assert_eq!(log.len(), 3);
-        assert!(log[0].message.contains("commit 3")); // Most recent first
-        assert!(log[2].message.contains("commit 1"));
-    }
-
-    #[test]
-    fn test_git_log_limit() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Make 5 commits
-        for i in 1..=5 {
-            create_file(&temp_dir, &format!("file{}.txt", i), "content");
-            run_git_command(&working_dir, &["add", "-A"]).unwrap();
-            run_git_command(&working_dir, &["commit", "-m", &format!("commit {}", i)]).unwrap();
-        }
-
-        // Only get last 2
-        let result = git_log(working_dir, Some(2));
-        assert!(result.is_ok());
-
-        let log = result.unwrap();
-        assert_eq!(log.len(), 2);
-    }
-
-    // ==================== git_discard tests ====================
-
-    #[test]
-    fn test_git_discard_changes() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Create and commit a file
-        create_file(&temp_dir, "file.txt", "original content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        // Modify the file
-        create_file(&temp_dir, "file.txt", "modified content");
-
-        // Discard changes
-        let result = git_discard(working_dir.clone(), "file.txt".to_string());
-        assert!(result.is_ok());
-
-        // Verify file contents are restored
-        let content = fs::read_to_string(temp_dir.path().join("file.txt")).unwrap();
-        assert_eq!(content, "original content");
-    }
-
-    // ==================== git_create_branch tests ====================
-
-    #[test]
-    fn test_git_create_branch() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Initial commit required
-        create_file(&temp_dir, "file.txt", "content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        let result = git_create_branch(working_dir.clone(), "new-branch".to_string());
-        assert!(result.is_ok());
-
-        // Verify branch exists and is current
-        let branches = git_branches(working_dir).unwrap();
-        assert!(branches.iter().any(|b| b.name == "new-branch" && b.is_current));
-    }
-
-    // ==================== git_checkout tests ====================
-
-    #[test]
-    fn test_git_checkout() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // Initial commit required
-        create_file(&temp_dir, "file.txt", "content");
-        run_git_command(&working_dir, &["add", "file.txt"]).unwrap();
-        run_git_command(&working_dir, &["commit", "-m", "initial"]).unwrap();
-
-        // Create a branch
-        run_git_command(&working_dir, &["branch", "other-branch"]).unwrap();
-
-        // Checkout the branch
-        let result = git_checkout(working_dir.clone(), "other-branch".to_string());
-        assert!(result.is_ok());
-
-        // Verify current branch
-        let branches = git_branches(working_dir).unwrap();
-        let current = branches.iter().find(|b| b.is_current);
-        assert!(current.is_some());
-        assert_eq!(current.unwrap().name, "other-branch");
-    }
-
-    // ==================== run_git_command tests ====================
-
-    #[test]
-    fn test_run_git_command_success() {
-        let temp_dir = create_test_repo();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        let result = run_git_command(&working_dir, &["status"]);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_run_git_command_failure() {
-        let temp_dir = TempDir::new().unwrap();
-        let working_dir = temp_dir.path().to_string_lossy().to_string();
-
-        // This should fail because it's not a git repo
-        let result = run_git_command(&working_dir, &["log"]);
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn test_run_git_command_invalid_dir() {
-        let result = run_git_command("/nonexistent/path", &["status"]);
-        assert!(result.is_err());
-    }
-}

src-tauri/src/quick_actions.rs

@@ -171,18 +171,6 @@ pub async fn reset_default_quick_actions(app: AppHandle) -> Result<(), String> {
 mod tests {
     use super::*;
 
-    fn create_test_action(id: &str, name: &str, is_default: bool) -> QuickAction {
-        QuickAction {
-            id: id.to_string(),
-            name: name.to_string(),
-            prompt: "Test prompt".to_string(),
-            icon: "star".to_string(),
-            is_default,
-            created_at: Utc::now(),
-            updated_at: Utc::now(),
-        }
-    }
-
     #[test]
     fn test_default_quick_actions_exist() {
         let defaults = get_default_quick_actions();
@@ -200,174 +188,4 @@ mod tests {
             assert!(!action.icon.is_empty());
         }
     }
-
-    #[test]
-    fn test_default_quick_actions_count() {
-        let defaults = get_default_quick_actions();
-        // Should have 6 default actions
-        assert_eq!(defaults.len(), 6);
-    }
-
-    #[test]
-    fn test_default_quick_actions_have_unique_ids() {
-        let defaults = get_default_quick_actions();
-        let mut ids: Vec<&String> = defaults.iter().map(|a| &a.id).collect();
-        ids.sort();
-        ids.dedup();
-        assert_eq!(ids.len(), defaults.len());
-    }
-
-    #[test]
-    fn test_default_quick_actions_ids_start_with_default() {
-        let defaults = get_default_quick_actions();
-        assert!(defaults.iter().all(|a| a.id.starts_with("default-")));
-    }
-
-    #[test]
-    fn test_quick_action_serialization() {
-        let action = create_test_action("test-1", "Test Action", false);
-        let json = serde_json::to_string(&action).expect("Failed to serialize");
-        let parsed: QuickAction = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        assert_eq!(parsed.id, action.id);
-        assert_eq!(parsed.name, action.name);
-        assert_eq!(parsed.prompt, action.prompt);
-        assert_eq!(parsed.icon, action.icon);
-        assert_eq!(parsed.is_default, action.is_default);
-    }
-
-    #[test]
-    fn test_quick_action_clone() {
-        let original = create_test_action("clone-test", "Clone Test", true);
-        let cloned = original.clone();
-
-        assert_eq!(original.id, cloned.id);
-        assert_eq!(original.name, cloned.name);
-        assert_eq!(original.is_default, cloned.is_default);
-    }
-
-    #[test]
-    #[allow(clippy::useless_vec)]
-    fn test_quick_action_sorting_defaults_first() {
-        let mut actions = vec![
-            create_test_action("custom-z", "Zebra", false),
-            create_test_action("default-a", "Apple", true),
-            create_test_action("custom-a", "Alpha", false),
-            create_test_action("default-z", "Zulu", true),
-        ];
-
-        // Sort by: defaults first, then alphabetically by name
-        actions.sort_by(|a, b| {
-            let default_cmp = b.is_default.cmp(&a.is_default);
-            if default_cmp == std::cmp::Ordering::Equal {
-                a.name.cmp(&b.name)
-            } else {
-                default_cmp
-            }
-        });
-
-        // Defaults should come first
-        assert!(actions[0].is_default);
-        assert!(actions[1].is_default);
-        assert!(!actions[2].is_default);
-        assert!(!actions[3].is_default);
-
-        // Within defaults, alphabetically sorted
-        assert_eq!(actions[0].name, "Apple");
-        assert_eq!(actions[1].name, "Zulu");
-
-        // Within non-defaults, alphabetically sorted
-        assert_eq!(actions[2].name, "Alpha");
-        assert_eq!(actions[3].name, "Zebra");
-    }
-
-    #[test]
-    fn test_known_default_actions() {
-        let defaults = get_default_quick_actions();
-        let ids: Vec<&str> = defaults.iter().map(|a| a.id.as_str()).collect();
-
-        assert!(ids.contains(&"default-review-pr"));
-        assert!(ids.contains(&"default-run-tests"));
-        assert!(ids.contains(&"default-explain-file"));
-        assert!(ids.contains(&"default-fix-error"));
-        assert!(ids.contains(&"default-write-tests"));
-        assert!(ids.contains(&"default-refactor"));
-    }
-
-    #[test]
-    fn test_default_action_icons() {
-        let defaults = get_default_quick_actions();
-        let icons: Vec<&str> = defaults.iter().map(|a| a.icon.as_str()).collect();
-
-        assert!(icons.contains(&"git-pull-request"));
-        assert!(icons.contains(&"play"));
-        assert!(icons.contains(&"file-text"));
-        assert!(icons.contains(&"alert-circle"));
-        assert!(icons.contains(&"check-square"));
-        assert!(icons.contains(&"refresh-cw"));
-    }
-
-    #[test]
-    fn test_quick_action_prompts_not_empty() {
-        let defaults = get_default_quick_actions();
-        for action in defaults {
-            assert!(
-                action.prompt.len() > 10,
-                "Prompt should be meaningful: {}",
-                action.name
-            );
-        }
-    }
-
-    #[test]
-    fn test_quick_action_timestamps() {
-        let action = create_test_action("time-test", "Time Test", false);
-        assert!(action.created_at <= action.updated_at);
-    }
-
-    #[test]
-    fn test_default_actions_have_same_timestamps() {
-        let defaults = get_default_quick_actions();
-        // All defaults are created at the same instant
-        let first_created = defaults[0].created_at;
-        let first_updated = defaults[0].updated_at;
-
-        for action in &defaults {
-            assert_eq!(action.created_at, first_created);
-            assert_eq!(action.updated_at, first_updated);
-        }
-    }
-
-    #[test]
-    fn test_action_retain_non_default() {
-        let mut actions = vec![
-            create_test_action("default-1", "Default 1", true),
-            create_test_action("custom-1", "Custom 1", false),
-            create_test_action("default-2", "Default 2", true),
-            create_test_action("custom-2", "Custom 2", false),
-        ];
-
-        // Mimics reset_default_quick_actions behavior (retain non-defaults)
-        actions.retain(|a| !a.is_default);
-
-        assert_eq!(actions.len(), 2);
-        assert!(actions.iter().all(|a| !a.is_default));
-    }
-
-    #[test]
-    #[allow(clippy::useless_vec)]
-    fn test_action_find_by_id() {
-        let actions = vec![
-            create_test_action("action-1", "First", false),
-            create_test_action("action-2", "Second", false),
-            create_test_action("action-3", "Third", false),
-        ];
-
-        let found = actions.iter().find(|a| a.id == "action-2");
-        assert!(found.is_some());
-        assert_eq!(found.unwrap().name, "Second");
-
-        let not_found = actions.iter().find(|a| a.id == "action-999");
-        assert!(not_found.is_none());
-    }
 }

src-tauri/src/sessions.rs

@@ -145,30 +145,6 @@ pub async fn clear_all_sessions(app: AppHandle) -> Result<(), String> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use chrono::TimeZone;
-
-    fn create_test_session(id: &str, name: &str) -> SavedSession {
-        SavedSession {
-            id: id.to_string(),
-            name: name.to_string(),
-            created_at: Utc::now(),
-            last_activity_at: Utc::now(),
-            working_directory: "/home/test".to_string(),
-            message_count: 5,
-            preview: "Hello world".to_string(),
-            messages: vec![],
-        }
-    }
-
-    fn create_test_message(id: &str, content: &str, msg_type: &str) -> SavedMessage {
-        SavedMessage {
-            id: id.to_string(),
-            message_type: msg_type.to_string(),
-            content: content.to_string(),
-            timestamp: Utc::now(),
-            tool_name: None,
-        }
-    }
 
     #[test]
     fn test_session_list_item_from_saved_session() {
@@ -188,187 +164,4 @@ mod tests {
         assert_eq!(item.name, "Test Session");
         assert_eq!(item.message_count, 5);
     }
-
-    #[test]
-    fn test_session_list_item_preserves_all_fields() {
-        let created = Utc.with_ymd_and_hms(2024, 1, 15, 10, 30, 0).unwrap();
-        let last_activity = Utc.with_ymd_and_hms(2024, 1, 15, 14, 45, 0).unwrap();
-
-        let session = SavedSession {
-            id: "sess-123".to_string(),
-            name: "My Chat".to_string(),
-            created_at: created,
-            last_activity_at: last_activity,
-            working_directory: "/home/naomi/project".to_string(),
-            message_count: 42,
-            preview: "What is the meaning of life?".to_string(),
-            messages: vec![],
-        };
-
-        let item = SessionListItem::from(&session);
-
-        assert_eq!(item.id, "sess-123");
-        assert_eq!(item.name, "My Chat");
-        assert_eq!(item.created_at, created);
-        assert_eq!(item.last_activity_at, last_activity);
-        assert_eq!(item.working_directory, "/home/naomi/project");
-        assert_eq!(item.message_count, 42);
-        assert_eq!(item.preview, "What is the meaning of life?");
-    }
-
-    #[test]
-    fn test_saved_session_serialization() {
-        let session = create_test_session("test-1", "Test Session");
-        let json = serde_json::to_string(&session).expect("Failed to serialize");
-        let parsed: SavedSession = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        assert_eq!(parsed.id, session.id);
-        assert_eq!(parsed.name, session.name);
-        assert_eq!(parsed.working_directory, session.working_directory);
-    }
-
-    #[test]
-    fn test_saved_message_serialization() {
-        let message = create_test_message("msg-1", "Hello!", "user");
-        let json = serde_json::to_string(&message).expect("Failed to serialize");
-        let parsed: SavedMessage = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        assert_eq!(parsed.id, message.id);
-        assert_eq!(parsed.content, message.content);
-        assert_eq!(parsed.message_type, "user");
-    }
-
-    #[test]
-    fn test_saved_message_with_tool_name() {
-        let message = SavedMessage {
-            id: "msg-tool-1".to_string(),
-            message_type: "tool".to_string(),
-            content: "File read successfully".to_string(),
-            timestamp: Utc::now(),
-            tool_name: Some("Read".to_string()),
-        };
-
-        let json = serde_json::to_string(&message).expect("Failed to serialize");
-        let parsed: SavedMessage = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        assert_eq!(parsed.tool_name, Some("Read".to_string()));
-    }
-
-    #[test]
-    fn test_session_with_messages_serialization() {
-        let mut session = create_test_session("sess-full", "Full Session");
-        session.messages = vec![
-            create_test_message("msg-1", "Hello!", "user"),
-            create_test_message("msg-2", "Hi there!", "assistant"),
-            create_test_message("msg-3", "Read file", "tool"),
-        ];
-        session.message_count = 3;
-
-        let json = serde_json::to_string(&session).expect("Failed to serialize");
-        let parsed: SavedSession = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        assert_eq!(parsed.messages.len(), 3);
-        assert_eq!(parsed.messages[0].content, "Hello!");
-        assert_eq!(parsed.messages[1].message_type, "assistant");
-        assert_eq!(parsed.messages[2].message_type, "tool");
-    }
-
-    #[test]
-    fn test_session_list_item_serialization() {
-        let item = SessionListItem {
-            id: "list-item-1".to_string(),
-            name: "Quick Chat".to_string(),
-            created_at: Utc::now(),
-            last_activity_at: Utc::now(),
-            working_directory: "/tmp".to_string(),
-            message_count: 10,
-            preview: "Short preview...".to_string(),
-        };
-
-        let json = serde_json::to_string(&item).expect("Failed to serialize");
-        let parsed: SessionListItem = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        assert_eq!(parsed.id, item.id);
-        assert_eq!(parsed.name, item.name);
-        assert_eq!(parsed.preview, item.preview);
-    }
-
-    #[test]
-    fn test_message_type_field_rename() {
-        // The message_type field is renamed to "type" in JSON
-        let message = create_test_message("msg-1", "Test", "assistant");
-        let json = serde_json::to_string(&message).expect("Failed to serialize");
-
-        assert!(json.contains("\"type\":"));
-        assert!(!json.contains("\"message_type\":"));
-    }
-
-    #[test]
-    fn test_session_default_empty_messages() {
-        let session = SavedSession {
-            id: "empty".to_string(),
-            name: "Empty".to_string(),
-            created_at: Utc::now(),
-            last_activity_at: Utc::now(),
-            working_directory: "/".to_string(),
-            message_count: 0,
-            preview: "".to_string(),
-            messages: vec![],
-        };
-
-        assert!(session.messages.is_empty());
-        assert_eq!(session.message_count, 0);
-    }
-
-    #[test]
-    #[allow(clippy::useless_vec)]
-    fn test_session_sorting_by_activity() {
-        let old_time = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap();
-        let new_time = Utc.with_ymd_and_hms(2024, 6, 15, 12, 0, 0).unwrap();
-
-        let mut sessions = vec![
-            SessionListItem {
-                id: "old".to_string(),
-                name: "Old Session".to_string(),
-                created_at: old_time,
-                last_activity_at: old_time,
-                working_directory: "/old".to_string(),
-                message_count: 1,
-                preview: "Old".to_string(),
-            },
-            SessionListItem {
-                id: "new".to_string(),
-                name: "New Session".to_string(),
-                created_at: new_time,
-                last_activity_at: new_time,
-                working_directory: "/new".to_string(),
-                message_count: 1,
-                preview: "New".to_string(),
-            },
-        ];
-
-        // Sort by last activity, most recent first (mimics list_sessions behavior)
-        sessions.sort_by(|a, b| b.last_activity_at.cmp(&a.last_activity_at));
-
-        assert_eq!(sessions[0].id, "new");
-        assert_eq!(sessions[1].id, "old");
-    }
-
-    #[test]
-    fn test_session_clone() {
-        let original = create_test_session("clone-test", "Clone Test");
-        let cloned = original.clone();
-
-        assert_eq!(original.id, cloned.id);
-        assert_eq!(original.name, cloned.name);
-    }
-
-    #[test]
-    fn test_message_clone() {
-        let original = create_test_message("msg-clone", "Content", "user");
-        let cloned = original.clone();
-
-        assert_eq!(original.id, cloned.id);
-        assert_eq!(original.content, cloned.content);
-    }
 }

src-tauri/src/snippets.rs

@@ -205,19 +205,6 @@ pub async fn reset_default_snippets(app: AppHandle) -> Result<(), String> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::collections::HashSet;
-
-    fn create_test_snippet(id: &str, name: &str, category: &str, is_default: bool) -> Snippet {
-        Snippet {
-            id: id.to_string(),
-            name: name.to_string(),
-            content: "Test content".to_string(),
-            category: category.to_string(),
-            is_default,
-            created_at: Utc::now(),
-            updated_at: Utc::now(),
-        }
-    }
 
     #[test]
     fn test_default_snippets_exist() {
@@ -236,204 +223,4 @@ mod tests {
             assert!(!snippet.category.is_empty());
         }
     }
-
-    #[test]
-    fn test_default_snippets_count() {
-        let defaults = get_default_snippets();
-        // Should have 8 default snippets
-        assert_eq!(defaults.len(), 8);
-    }
-
-    #[test]
-    fn test_default_snippets_have_unique_ids() {
-        let defaults = get_default_snippets();
-        let ids: HashSet<&String> = defaults.iter().map(|s| &s.id).collect();
-        assert_eq!(ids.len(), defaults.len());
-    }
-
-    #[test]
-    fn test_default_snippets_ids_start_with_default() {
-        let defaults = get_default_snippets();
-        assert!(defaults.iter().all(|s| s.id.starts_with("default-")));
-    }
-
-    #[test]
-    fn test_snippet_serialization() {
-        let snippet = create_test_snippet("test-1", "Test Snippet", "Testing", false);
-        let json = serde_json::to_string(&snippet).expect("Failed to serialize");
-        let parsed: Snippet = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        assert_eq!(parsed.id, snippet.id);
-        assert_eq!(parsed.name, snippet.name);
-        assert_eq!(parsed.content, snippet.content);
-        assert_eq!(parsed.category, snippet.category);
-        assert_eq!(parsed.is_default, snippet.is_default);
-    }
-
-    #[test]
-    fn test_snippet_clone() {
-        let original = create_test_snippet("clone-test", "Clone Test", "Category", true);
-        let cloned = original.clone();
-
-        assert_eq!(original.id, cloned.id);
-        assert_eq!(original.name, cloned.name);
-        assert_eq!(original.is_default, cloned.is_default);
-    }
-
-    #[test]
-    #[allow(clippy::useless_vec)]
-    fn test_snippet_sorting_by_category_then_name() {
-        let mut snippets = vec![
-            create_test_snippet("s1", "Zebra", "B-Category", false),
-            create_test_snippet("s2", "Apple", "A-Category", false),
-            create_test_snippet("s3", "Banana", "B-Category", false),
-            create_test_snippet("s4", "Alpha", "A-Category", false),
-        ];
-
-        // Sort by category, then by name (mimics list_snippets behavior)
-        snippets.sort_by(|a, b| {
-            let cat_cmp = a.category.cmp(&b.category);
-            if cat_cmp == std::cmp::Ordering::Equal {
-                a.name.cmp(&b.name)
-            } else {
-                cat_cmp
-            }
-        });
-
-        // A-Category should come first
-        assert_eq!(snippets[0].category, "A-Category");
-        assert_eq!(snippets[1].category, "A-Category");
-        assert_eq!(snippets[2].category, "B-Category");
-        assert_eq!(snippets[3].category, "B-Category");
-
-        // Within categories, alphabetically by name
-        assert_eq!(snippets[0].name, "Alpha");
-        assert_eq!(snippets[1].name, "Apple");
-        assert_eq!(snippets[2].name, "Banana");
-        assert_eq!(snippets[3].name, "Zebra");
-    }
-
-    #[test]
-    fn test_known_default_snippets() {
-        let defaults = get_default_snippets();
-        let ids: Vec<&str> = defaults.iter().map(|s| s.id.as_str()).collect();
-
-        assert!(ids.contains(&"default-explain-code"));
-        assert!(ids.contains(&"default-fix-error"));
-        assert!(ids.contains(&"default-write-tests"));
-        assert!(ids.contains(&"default-refactor"));
-        assert!(ids.contains(&"default-optimize"));
-        assert!(ids.contains(&"default-review-pr"));
-        assert!(ids.contains(&"default-add-comments"));
-        assert!(ids.contains(&"default-security-review"));
-    }
-
-    #[test]
-    fn test_default_snippet_categories() {
-        let defaults = get_default_snippets();
-        let categories: HashSet<&String> = defaults.iter().map(|s| &s.category).collect();
-
-        assert!(categories.contains(&"Code Review".to_string()));
-        assert!(categories.contains(&"Debugging".to_string()));
-        assert!(categories.contains(&"Testing".to_string()));
-        assert!(categories.contains(&"Performance".to_string()));
-        assert!(categories.contains(&"Documentation".to_string()));
-        assert!(categories.contains(&"Security".to_string()));
-    }
-
-    #[test]
-    fn test_snippet_content_not_empty() {
-        let defaults = get_default_snippets();
-        for snippet in defaults {
-            assert!(
-                snippet.content.len() > 10,
-                "Content should be meaningful: {}",
-                snippet.name
-            );
-        }
-    }
-
-    #[test]
-    fn test_snippet_timestamps() {
-        let snippet = create_test_snippet("time-test", "Time Test", "Cat", false);
-        assert!(snippet.created_at <= snippet.updated_at);
-    }
-
-    #[test]
-    fn test_default_snippets_have_same_timestamps() {
-        let defaults = get_default_snippets();
-        // All defaults are created at the same instant
-        let first_created = defaults[0].created_at;
-        let first_updated = defaults[0].updated_at;
-
-        for snippet in &defaults {
-            assert_eq!(snippet.created_at, first_created);
-            assert_eq!(snippet.updated_at, first_updated);
-        }
-    }
-
-    #[test]
-    fn test_snippet_retain_non_default() {
-        let mut snippets = vec![
-            create_test_snippet("default-1", "Default 1", "Cat", true),
-            create_test_snippet("custom-1", "Custom 1", "Cat", false),
-            create_test_snippet("default-2", "Default 2", "Cat", true),
-            create_test_snippet("custom-2", "Custom 2", "Cat", false),
-        ];
-
-        // Mimics reset_default_snippets behavior (retain non-defaults)
-        snippets.retain(|s| !s.is_default);
-
-        assert_eq!(snippets.len(), 2);
-        assert!(snippets.iter().all(|s| !s.is_default));
-    }
-
-    #[test]
-    #[allow(clippy::useless_vec)]
-    fn test_snippet_find_by_id() {
-        let snippets = vec![
-            create_test_snippet("snippet-1", "First", "Cat", false),
-            create_test_snippet("snippet-2", "Second", "Cat", false),
-            create_test_snippet("snippet-3", "Third", "Cat", false),
-        ];
-
-        let found = snippets.iter().find(|s| s.id == "snippet-2");
-        assert!(found.is_some());
-        assert_eq!(found.unwrap().name, "Second");
-
-        let not_found = snippets.iter().find(|s| s.id == "snippet-999");
-        assert!(not_found.is_none());
-    }
-
-    #[test]
-    #[allow(clippy::useless_vec)]
-    fn test_extract_categories_sorted_and_deduped() {
-        let snippets = vec![
-            create_test_snippet("s1", "S1", "Zebra", false),
-            create_test_snippet("s2", "S2", "Alpha", false),
-            create_test_snippet("s3", "S3", "Beta", false),
-            create_test_snippet("s4", "S4", "Alpha", false), // Duplicate
-        ];
-
-        let mut categories: Vec<String> = snippets.iter().map(|s| s.category.clone()).collect();
-        categories.sort();
-        categories.dedup();
-
-        assert_eq!(categories.len(), 3);
-        assert_eq!(categories[0], "Alpha");
-        assert_eq!(categories[1], "Beta");
-        assert_eq!(categories[2], "Zebra");
-    }
-
-    #[test]
-    fn test_snippet_category_code_review_count() {
-        let defaults = get_default_snippets();
-        let code_review_count = defaults
-            .iter()
-            .filter(|s| s.category == "Code Review")
-            .count();
-
-        // There should be multiple code review snippets
-        assert!(code_review_count >= 2);
-    }
 }

src-tauri/src/stats.rs

@@ -369,36 +369,6 @@ mod tests {
         assert!((cost - 0.165).abs() < 0.0001);
     }
 
-    #[test]
-    fn test_cost_calculation_opus_45() {
-        let cost = calculate_cost(1000, 2000, "claude-opus-4-5-20251101");
-        // Same pricing as Opus 4
-        assert!((cost - 0.165).abs() < 0.0001);
-    }
-
-    #[test]
-    fn test_cost_calculation_haiku() {
-        let cost = calculate_cost(1000, 2000, "claude-3-5-haiku-20241022");
-        // 1000 input * $1/M = $0.001
-        // 2000 output * $5/M = $0.010
-        // Total = $0.011
-        assert!((cost - 0.011).abs() < 0.0001);
-    }
-
-    #[test]
-    fn test_cost_calculation_unknown_defaults_to_sonnet() {
-        let cost = calculate_cost(1000, 2000, "some-unknown-model");
-        // Should default to Sonnet pricing
-        assert!((cost - 0.033).abs() < 0.0001);
-    }
-
-    #[test]
-    fn test_cost_calculation_legacy_sonnet() {
-        let cost = calculate_cost(1000, 2000, "claude-3-5-sonnet-20241022");
-        // Same as Sonnet 4 pricing
-        assert!((cost - 0.033).abs() < 0.0001);
-    }
-
     #[test]
     fn test_usage_stats_accumulation() {
         let mut stats = UsageStats::new();
@@ -411,28 +381,6 @@ mod tests {
         assert!((stats.total_cost_usd - 0.033).abs() < 0.0001);
     }
 
-    #[test]
-    fn test_usage_stats_multiple_accumulations() {
-        let mut stats = UsageStats::new();
-        stats.add_usage(1000, 1000, "claude-sonnet-4-20250514");
-        stats.add_usage(500, 500, "claude-sonnet-4-20250514");
-
-        assert_eq!(stats.total_input_tokens, 1500);
-        assert_eq!(stats.total_output_tokens, 1500);
-        assert_eq!(stats.session_input_tokens, 1500);
-        assert_eq!(stats.session_output_tokens, 1500);
-    }
-
-    #[test]
-    fn test_usage_stats_model_updated() {
-        let mut stats = UsageStats::new();
-        stats.add_usage(1000, 1000, "claude-sonnet-4-20250514");
-        assert_eq!(stats.model, Some("claude-sonnet-4-20250514".to_string()));
-
-        stats.add_usage(500, 500, "claude-opus-4-20250514");
-        assert_eq!(stats.model, Some("claude-opus-4-20250514".to_string()));
-    }
-
     #[test]
     fn test_session_reset() {
         let mut stats = UsageStats::new();
@@ -446,230 +394,4 @@ mod tests {
         assert_eq!(stats.session_cost_usd, 0.0);
         assert!(stats.total_cost_usd > 0.0);
     }
-
-    #[test]
-    fn test_session_reset_clears_session_stats() {
-        let mut stats = UsageStats::new();
-        stats.increment_messages();
-        stats.increment_messages();
-        stats.increment_code_blocks();
-        stats.increment_files_edited();
-        stats.increment_files_created();
-        stats.increment_tool_usage("Read");
-
-        stats.reset_session();
-
-        assert_eq!(stats.session_messages_exchanged, 0);
-        assert_eq!(stats.session_code_blocks_generated, 0);
-        assert_eq!(stats.session_files_edited, 0);
-        assert_eq!(stats.session_files_created, 0);
-        assert!(stats.session_tools_usage.is_empty());
-    }
-
-    #[test]
-    fn test_increment_messages() {
-        let mut stats = UsageStats::new();
-        stats.increment_messages();
-        stats.increment_messages();
-        stats.increment_messages();
-
-        assert_eq!(stats.messages_exchanged, 3);
-        assert_eq!(stats.session_messages_exchanged, 3);
-    }
-
-    #[test]
-    fn test_increment_code_blocks() {
-        let mut stats = UsageStats::new();
-        stats.increment_code_blocks();
-        stats.increment_code_blocks();
-
-        assert_eq!(stats.code_blocks_generated, 2);
-        assert_eq!(stats.session_code_blocks_generated, 2);
-    }
-
-    #[test]
-    fn test_increment_files_edited() {
-        let mut stats = UsageStats::new();
-        stats.increment_files_edited();
-
-        assert_eq!(stats.files_edited, 1);
-        assert_eq!(stats.session_files_edited, 1);
-    }
-
-    #[test]
-    fn test_increment_files_created() {
-        let mut stats = UsageStats::new();
-        stats.increment_files_created();
-
-        assert_eq!(stats.files_created, 1);
-        assert_eq!(stats.session_files_created, 1);
-    }
-
-    #[test]
-    fn test_increment_tool_usage() {
-        let mut stats = UsageStats::new();
-        stats.increment_tool_usage("Read");
-        stats.increment_tool_usage("Read");
-        stats.increment_tool_usage("Write");
-
-        assert_eq!(stats.tools_usage.get("Read"), Some(&2));
-        assert_eq!(stats.tools_usage.get("Write"), Some(&1));
-        assert_eq!(stats.session_tools_usage.get("Read"), Some(&2));
-        assert_eq!(stats.session_tools_usage.get("Write"), Some(&1));
-    }
-
-    #[test]
-    fn test_session_duration_tracking() {
-        let mut stats = UsageStats::new();
-        stats.session_start = Some(Instant::now());
-
-        // Verify duration is returned (u64 is always non-negative)
-        let _duration = stats.get_session_duration();
-    }
-
-    #[test]
-    fn test_session_duration_without_start() {
-        let mut stats = UsageStats::new();
-        stats.session_start = None;
-        stats.session_duration_seconds = 100;
-
-        // Should return the stored value when no start time
-        let duration = stats.get_session_duration();
-        assert_eq!(duration, 100);
-    }
-
-    #[test]
-    fn test_is_consecutive_day_true() {
-        assert!(is_consecutive_day("2024-01-15", "2024-01-16"));
-        assert!(is_consecutive_day("2024-12-31", "2025-01-01"));
-    }
-
-    #[test]
-    fn test_is_consecutive_day_false() {
-        assert!(!is_consecutive_day("2024-01-15", "2024-01-15")); // Same day
-        assert!(!is_consecutive_day("2024-01-15", "2024-01-17")); // Gap
-        assert!(!is_consecutive_day("2024-01-15", "2024-01-14")); // Backwards
-    }
-
-    #[test]
-    fn test_is_consecutive_day_invalid_dates() {
-        assert!(!is_consecutive_day("invalid", "2024-01-01"));
-        assert!(!is_consecutive_day("2024-01-01", "invalid"));
-        assert!(!is_consecutive_day("invalid", "also-invalid"));
-    }
-
-    #[test]
-    fn test_persisted_stats_from_usage_stats() {
-        let mut stats = UsageStats::new();
-        stats.total_input_tokens = 5000;
-        stats.total_output_tokens = 10000;
-        stats.total_cost_usd = 1.23;
-        stats.messages_exchanged = 50;
-        stats.sessions_started = 5;
-        stats.consecutive_days = 3;
-
-        let persisted = PersistedStats::from(&stats);
-
-        assert_eq!(persisted.total_input_tokens, 5000);
-        assert_eq!(persisted.total_output_tokens, 10000);
-        assert_eq!(persisted.total_cost_usd, 1.23);
-        assert_eq!(persisted.messages_exchanged, 50);
-        assert_eq!(persisted.sessions_started, 5);
-        assert_eq!(persisted.consecutive_days, 3);
-    }
-
-    #[test]
-    fn test_apply_persisted_stats() {
-        let persisted = PersistedStats {
-            total_input_tokens: 10000,
-            total_output_tokens: 20000,
-            total_cost_usd: 5.50,
-            messages_exchanged: 100,
-            code_blocks_generated: 25,
-            files_edited: 10,
-            files_created: 5,
-            tools_usage: {
-                let mut map = HashMap::new();
-                map.insert("Read".to_string(), 50);
-                map
-            },
-            sessions_started: 10,
-            consecutive_days: 7,
-            total_days_used: 14,
-            morning_sessions: 3,
-            night_sessions: 2,
-            last_session_date: Some("2024-06-15".to_string()),
-        };
-
-        let mut stats = UsageStats::new();
-        stats.apply_persisted(persisted);
-
-        assert_eq!(stats.total_input_tokens, 10000);
-        assert_eq!(stats.total_output_tokens, 20000);
-        assert_eq!(stats.total_cost_usd, 5.50);
-        assert_eq!(stats.messages_exchanged, 100);
-        assert_eq!(stats.tools_usage.get("Read"), Some(&50));
-        assert_eq!(stats.consecutive_days, 7);
-        assert_eq!(stats.morning_sessions, 3);
-        assert_eq!(stats.last_session_date, Some("2024-06-15".to_string()));
-    }
-
-    #[test]
-    fn test_usage_stats_default() {
-        let stats = UsageStats::default();
-
-        assert_eq!(stats.total_input_tokens, 0);
-        assert_eq!(stats.total_output_tokens, 0);
-        assert_eq!(stats.total_cost_usd, 0.0);
-        assert!(stats.model.is_none());
-    }
-
-    #[test]
-    fn test_persisted_stats_default() {
-        let persisted = PersistedStats::default();
-
-        assert_eq!(persisted.total_input_tokens, 0);
-        assert!(persisted.last_session_date.is_none());
-    }
-
-    #[test]
-    fn test_usage_stats_serialization() {
-        let mut stats = UsageStats::new();
-        stats.add_usage(1000, 2000, "claude-sonnet-4-20250514");
-        stats.increment_messages();
-
-        // UsageStats should be serializable (for events)
-        let json = serde_json::to_string(&stats).expect("Failed to serialize");
-        assert!(json.contains("total_input_tokens"));
-        assert!(json.contains("1000"));
-    }
-
-    #[test]
-    fn test_persisted_stats_serialization() {
-        let persisted = PersistedStats {
-            total_input_tokens: 1234,
-            total_output_tokens: 5678,
-            total_cost_usd: 0.99,
-            ..Default::default()
-        };
-
-        let json = serde_json::to_string(&persisted).expect("Failed to serialize");
-        let parsed: PersistedStats = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        assert_eq!(parsed.total_input_tokens, 1234);
-        assert_eq!(parsed.total_output_tokens, 5678);
-        assert!((parsed.total_cost_usd - 0.99).abs() < 0.0001);
-    }
-
-    #[test]
-    fn test_stats_update_event_serialization() {
-        let mut stats = UsageStats::new();
-        stats.add_usage(100, 200, "claude-sonnet-4-20250514");
-
-        let event = StatsUpdateEvent { stats };
-        let json = serde_json::to_string(&event).expect("Failed to serialize");
-
-        assert!(json.contains("stats"));
-        assert!(json.contains("total_input_tokens"));
-    }
 }

src-tauri/src/temp_manager.rs

@@ -137,290 +137,3 @@ pub type SharedTempFileManager = Arc<Mutex<TempFileManager>>;
 pub fn create_shared_temp_manager() -> Result<SharedTempFileManager, String> {
     Ok(Arc::new(Mutex::new(TempFileManager::new()?)))
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::fs;
-    use tempfile::TempDir;
-
-    // Helper to create a TempFileManager with a custom base directory for testing
-    fn create_test_manager(base_dir: PathBuf) -> TempFileManager {
-        if !base_dir.exists() {
-            fs::create_dir_all(&base_dir).expect("Failed to create test temp dir");
-        }
-        TempFileManager {
-            base_dir,
-            files: HashMap::new(),
-        }
-    }
-
-    #[test]
-    fn test_new_creates_base_directory() {
-        let manager = TempFileManager::new().expect("Failed to create TempFileManager");
-        assert!(manager.base_dir.exists());
-    }
-
-    #[test]
-    fn test_get_base_dir_returns_correct_path() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let manager = create_test_manager(base_path.clone());
-
-        assert_eq!(manager.get_base_dir(), base_path.as_path());
-    }
-
-    #[test]
-    fn test_save_file_creates_file_with_content() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let data = b"Hello, world!";
-        let result = manager.save_file("conv-1", data, Some("test.txt"));
-
-        assert!(result.is_ok());
-        let file_path = result.unwrap();
-        assert!(file_path.exists());
-
-        let content = fs::read(&file_path).expect("Failed to read file");
-        assert_eq!(content, data);
-    }
-
-    #[test]
-    fn test_save_file_uses_correct_extension() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let data = b"test data";
-        let result = manager.save_file("conv-1", data, Some("document.pdf"));
-
-        assert!(result.is_ok());
-        let file_path = result.unwrap();
-        assert_eq!(file_path.extension().unwrap(), "pdf");
-    }
-
-    #[test]
-    fn test_save_file_uses_bin_extension_when_no_filename() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let data = b"binary data";
-        let result = manager.save_file("conv-1", data, None);
-
-        assert!(result.is_ok());
-        let file_path = result.unwrap();
-        assert_eq!(file_path.extension().unwrap(), "bin");
-    }
-
-    #[test]
-    fn test_register_file_tracks_file_path() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let file_path = PathBuf::from("/some/path/file.txt");
-        manager.register_file("conv-1", file_path.clone());
-
-        let files = manager.get_files_for_conversation("conv-1");
-        assert_eq!(files.len(), 1);
-        assert_eq!(files[0], file_path);
-    }
-
-    #[test]
-    fn test_get_files_for_conversation_returns_empty_for_unknown() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let manager = create_test_manager(base_path);
-
-        let files = manager.get_files_for_conversation("unknown-conv");
-        assert!(files.is_empty());
-    }
-
-    #[test]
-    fn test_get_files_for_conversation_returns_all_files() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let data = b"test";
-        manager.save_file("conv-1", data, Some("file1.txt")).unwrap();
-        manager.save_file("conv-1", data, Some("file2.txt")).unwrap();
-        manager.save_file("conv-2", data, Some("file3.txt")).unwrap();
-
-        let files_conv1 = manager.get_files_for_conversation("conv-1");
-        let files_conv2 = manager.get_files_for_conversation("conv-2");
-
-        assert_eq!(files_conv1.len(), 2);
-        assert_eq!(files_conv2.len(), 1);
-    }
-
-    #[test]
-    fn test_cleanup_conversation_removes_files() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let data = b"test";
-        let file_path = manager.save_file("conv-1", data, Some("test.txt")).unwrap();
-        assert!(file_path.exists());
-
-        let result = manager.cleanup_conversation("conv-1");
-        assert!(result.is_ok());
-        assert!(!file_path.exists());
-        assert!(manager.get_files_for_conversation("conv-1").is_empty());
-    }
-
-    #[test]
-    fn test_cleanup_conversation_handles_missing_files() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        // Register a file that doesn't exist
-        manager.register_file("conv-1", PathBuf::from("/nonexistent/file.txt"));
-
-        // Should not error, just skip missing files
-        let result = manager.cleanup_conversation("conv-1");
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_cleanup_conversation_for_unknown_returns_ok() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let result = manager.cleanup_conversation("unknown-conv");
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_cleanup_all_removes_all_files() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let data = b"test";
-        let file1 = manager.save_file("conv-1", data, Some("f1.txt")).unwrap();
-        let file2 = manager.save_file("conv-2", data, Some("f2.txt")).unwrap();
-
-        assert!(file1.exists());
-        assert!(file2.exists());
-
-        let result = manager.cleanup_all();
-        assert!(result.is_ok());
-
-        assert!(!file1.exists());
-        assert!(!file2.exists());
-        assert!(manager.files.is_empty());
-    }
-
-    #[test]
-    fn test_cleanup_orphaned_files_removes_untracked() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path.clone());
-
-        // Create a tracked file
-        let data = b"tracked";
-        let tracked_path = manager.save_file("conv-1", data, Some("tracked.txt")).unwrap();
-
-        // Create an untracked (orphaned) file directly in the temp directory
-        let orphan_path = base_path.join("orphan.txt");
-        fs::write(&orphan_path, b"orphan").expect("Failed to create orphan file");
-
-        assert!(tracked_path.exists());
-        assert!(orphan_path.exists());
-
-        let result = manager.cleanup_orphaned_files();
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 1); // One orphan removed
-
-        assert!(tracked_path.exists()); // Tracked file still exists
-        assert!(!orphan_path.exists()); // Orphan removed
-    }
-
-    #[test]
-    fn test_cleanup_orphaned_returns_zero_when_none() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let data = b"test";
-        manager.save_file("conv-1", data, Some("test.txt")).unwrap();
-
-        let result = manager.cleanup_orphaned_files();
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 0);
-    }
-
-    #[test]
-    fn test_cleanup_orphaned_returns_zero_when_dir_missing() {
-        let mut manager = TempFileManager {
-            base_dir: PathBuf::from("/nonexistent/dir"),
-            files: HashMap::new(),
-        };
-
-        let result = manager.cleanup_orphaned_files();
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 0);
-    }
-
-    #[test]
-    fn test_default_creates_manager() {
-        // Default should work as long as we can create temp directories
-        let manager = TempFileManager::default();
-        assert!(manager.base_dir.exists());
-    }
-
-    #[test]
-    fn test_create_shared_temp_manager() {
-        let result = create_shared_temp_manager();
-        assert!(result.is_ok());
-
-        let shared = result.unwrap();
-        let manager = shared.lock();
-        assert!(manager.base_dir.exists());
-    }
-
-    #[test]
-    fn test_multiple_files_same_conversation() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        // Save multiple files to same conversation
-        for i in 0..5 {
-            let data = format!("content {}", i);
-            manager
-                .save_file("conv-1", data.as_bytes(), Some(&format!("file{}.txt", i)))
-                .unwrap();
-        }
-
-        let files = manager.get_files_for_conversation("conv-1");
-        assert_eq!(files.len(), 5);
-
-        // Each file should have unique content
-        for (i, file_path) in files.iter().enumerate() {
-            let content = fs::read_to_string(file_path).expect("Failed to read");
-            assert_eq!(content, format!("content {}", i));
-        }
-    }
-
-    #[test]
-    fn test_file_paths_contain_conversation_id() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let base_path = temp_dir.path().join("hikari-test");
-        let mut manager = create_test_manager(base_path);
-
-        let file_path = manager
-            .save_file("my-conversation-id", b"test", Some("test.txt"))
-            .unwrap();
-
-        let filename = file_path.file_name().unwrap().to_str().unwrap();
-        assert!(filename.starts_with("my-conversation-id_"));
-    }
-}

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "hikari-desktop",
-  "version": "1.0.0",
+  "version": "0.3.0",
   "identifier": "com.naomi.hikari-desktop",
   "build": {
     "beforeDevCommand": "pnpm dev",

src/lib/commands/slashCommands.test.ts

@@ -1,414 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import {
-  slashCommands,
-  parseSlashCommand,
-  getMatchingCommands,
-  isSlashCommand,
-  type SlashCommand,
-} from "./slashCommands";
-
-// Mock all external dependencies
-vi.mock("svelte/store", () => ({
-  get: vi.fn(),
-}));
-
-vi.mock("@tauri-apps/api/core", () => ({
-  invoke: vi.fn(),
-}));
-
-vi.mock("$lib/stores/claude", () => ({
-  claudeStore: {
-    addLine: vi.fn(),
-    clearTerminal: vi.fn(),
-    activeConversationId: { subscribe: vi.fn() },
-    currentWorkingDirectory: { subscribe: vi.fn() },
-    setWorkingDirectory: vi.fn(),
-    getConversationHistory: vi.fn(),
-  },
-}));
-
-vi.mock("$lib/stores/character", () => ({
-  characterState: {
-    setState: vi.fn(),
-    setTemporaryState: vi.fn(),
-  },
-}));
-
-vi.mock("$lib/tauri", () => ({
-  setSkipNextGreeting: vi.fn(),
-}));
-
-vi.mock("$lib/stores/search", () => ({
-  searchState: {
-    setQuery: vi.fn(),
-    clear: vi.fn(),
-  },
-}));
-
-describe("slashCommands", () => {
-  describe("slashCommands array", () => {
-    it("contains expected commands", () => {
-      const commandNames = slashCommands.map((cmd) => cmd.name);
-      expect(commandNames).toContain("cd");
-      expect(commandNames).toContain("clear");
-      expect(commandNames).toContain("new");
-      expect(commandNames).toContain("help");
-      expect(commandNames).toContain("search");
-      expect(commandNames).toContain("summarise");
-      expect(commandNames).toContain("skill");
-    });
-
-    it("has 7 commands total", () => {
-      expect(slashCommands.length).toBe(7);
-    });
-
-    it("each command has required properties", () => {
-      slashCommands.forEach((cmd) => {
-        expect(cmd.name).toBeDefined();
-        expect(typeof cmd.name).toBe("string");
-        expect(cmd.name.length).toBeGreaterThan(0);
-
-        expect(cmd.description).toBeDefined();
-        expect(typeof cmd.description).toBe("string");
-        expect(cmd.description.length).toBeGreaterThan(0);
-
-        expect(cmd.usage).toBeDefined();
-        expect(typeof cmd.usage).toBe("string");
-        expect(cmd.usage.startsWith("/")).toBe(true);
-
-        expect(cmd.execute).toBeDefined();
-        expect(typeof cmd.execute).toBe("function");
-      });
-    });
-
-    it("cd command has correct metadata", () => {
-      const cdCmd = slashCommands.find((cmd) => cmd.name === "cd");
-      expect(cdCmd).toBeDefined();
-      expect(cdCmd!.description).toBe("Change the working directory");
-      expect(cdCmd!.usage).toBe("/cd <path>");
-    });
-
-    it("clear command has correct metadata", () => {
-      const clearCmd = slashCommands.find((cmd) => cmd.name === "clear");
-      expect(clearCmd).toBeDefined();
-      expect(clearCmd!.description).toBe("Clear the terminal display (keeps conversation context)");
-      expect(clearCmd!.usage).toBe("/clear");
-    });
-
-    it("new command has correct metadata", () => {
-      const newCmd = slashCommands.find((cmd) => cmd.name === "new");
-      expect(newCmd).toBeDefined();
-      expect(newCmd!.description).toBe("Start a fresh conversation (resets context)");
-      expect(newCmd!.usage).toBe("/new");
-    });
-
-    it("help command has correct metadata", () => {
-      const helpCmd = slashCommands.find((cmd) => cmd.name === "help");
-      expect(helpCmd).toBeDefined();
-      expect(helpCmd!.description).toBe("Show available slash commands");
-      expect(helpCmd!.usage).toBe("/help");
-    });
-
-    it("search command has correct metadata", () => {
-      const searchCmd = slashCommands.find((cmd) => cmd.name === "search");
-      expect(searchCmd).toBeDefined();
-      expect(searchCmd!.description).toBe("Search within the conversation (use /search to clear)");
-      expect(searchCmd!.usage).toBe("/search [query]");
-    });
-
-    it("summarise command has correct metadata", () => {
-      const summariseCmd = slashCommands.find((cmd) => cmd.name === "summarise");
-      expect(summariseCmd).toBeDefined();
-      expect(summariseCmd!.description).toBe("Get a summary of the entire conversation");
-      expect(summariseCmd!.usage).toBe("/summarise");
-    });
-
-    it("skill command has correct metadata", () => {
-      const skillCmd = slashCommands.find((cmd) => cmd.name === "skill");
-      expect(skillCmd).toBeDefined();
-      expect(skillCmd!.description).toBe("Invoke a Claude Code skill from ~/.claude/skills/");
-      expect(skillCmd!.usage).toBe("/skill [name] [data]");
-    });
-  });
-
-  describe("parseSlashCommand", () => {
-    it("returns null for non-slash input", () => {
-      const result = parseSlashCommand("hello world");
-      expect(result.command).toBeNull();
-      expect(result.args).toBe("");
-    });
-
-    it("returns null for empty string", () => {
-      const result = parseSlashCommand("");
-      expect(result.command).toBeNull();
-      expect(result.args).toBe("");
-    });
-
-    it("returns null for whitespace only", () => {
-      const result = parseSlashCommand("   ");
-      expect(result.command).toBeNull();
-      expect(result.args).toBe("");
-    });
-
-    it("parses /cd command without args", () => {
-      const result = parseSlashCommand("/cd");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("cd");
-      expect(result.args).toBe("");
-    });
-
-    it("parses /cd command with path argument", () => {
-      const result = parseSlashCommand("/cd /home/naomi/code");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("cd");
-      expect(result.args).toBe("/home/naomi/code");
-    });
-
-    it("parses /clear command", () => {
-      const result = parseSlashCommand("/clear");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("clear");
-      expect(result.args).toBe("");
-    });
-
-    it("parses /new command", () => {
-      const result = parseSlashCommand("/new");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("new");
-      expect(result.args).toBe("");
-    });
-
-    it("parses /help command", () => {
-      const result = parseSlashCommand("/help");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("help");
-      expect(result.args).toBe("");
-    });
-
-    it("parses /search command with query", () => {
-      const result = parseSlashCommand("/search hello world");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("search");
-      expect(result.args).toBe("hello world");
-    });
-
-    it("parses /search command without query", () => {
-      const result = parseSlashCommand("/search");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("search");
-      expect(result.args).toBe("");
-    });
-
-    it("parses /summarise command", () => {
-      const result = parseSlashCommand("/summarise");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("summarise");
-      expect(result.args).toBe("");
-    });
-
-    it("parses /skill command with name and data", () => {
-      const result = parseSlashCommand("/skill onboard-mentee john@example.com");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("skill");
-      expect(result.args).toBe("onboard-mentee john@example.com");
-    });
-
-    it("parses /skill command with name only", () => {
-      const result = parseSlashCommand("/skill onboard-mentee");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("skill");
-      expect(result.args).toBe("onboard-mentee");
-    });
-
-    it("parses /skill command without arguments", () => {
-      const result = parseSlashCommand("/skill");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("skill");
-      expect(result.args).toBe("");
-    });
-
-    it("returns null for unknown command", () => {
-      const result = parseSlashCommand("/unknown");
-      expect(result.command).toBeNull();
-      expect(result.args).toBe("");
-    });
-
-    it("is case insensitive for command names", () => {
-      const result1 = parseSlashCommand("/CD /path");
-      expect(result1.command).not.toBeNull();
-      expect(result1.command!.name).toBe("cd");
-
-      const result2 = parseSlashCommand("/CLEAR");
-      expect(result2.command).not.toBeNull();
-      expect(result2.command!.name).toBe("clear");
-
-      const result3 = parseSlashCommand("/Help");
-      expect(result3.command).not.toBeNull();
-      expect(result3.command!.name).toBe("help");
-    });
-
-    it("handles leading whitespace", () => {
-      const result = parseSlashCommand("  /cd /path");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("cd");
-      expect(result.args).toBe("/path");
-    });
-
-    it("handles trailing whitespace", () => {
-      const result = parseSlashCommand("/cd /path  ");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("cd");
-      expect(result.args).toBe("/path");
-    });
-
-    it("handles multiple spaces between args", () => {
-      const result = parseSlashCommand("/search   hello   world");
-      expect(result.command).not.toBeNull();
-      expect(result.command!.name).toBe("search");
-      expect(result.args).toBe("hello world");
-    });
-  });
-
-  describe("getMatchingCommands", () => {
-    it("returns empty array for non-slash input", () => {
-      const result = getMatchingCommands("hello");
-      expect(result).toEqual([]);
-    });
-
-    it("returns empty array for empty string", () => {
-      const result = getMatchingCommands("");
-      expect(result).toEqual([]);
-    });
-
-    it("returns all commands for just slash", () => {
-      const result = getMatchingCommands("/");
-      expect(result.length).toBe(slashCommands.length);
-    });
-
-    it("returns matching commands for partial input", () => {
-      const result = getMatchingCommands("/c");
-      const names = result.map((cmd) => cmd.name);
-      expect(names).toContain("cd");
-      expect(names).toContain("clear");
-      expect(names).not.toContain("help");
-    });
-
-    it("returns single command for exact match", () => {
-      const result = getMatchingCommands("/cd");
-      expect(result.length).toBe(1);
-      expect(result[0].name).toBe("cd");
-    });
-
-    it("returns single command for partial unique match", () => {
-      const result = getMatchingCommands("/cl");
-      expect(result.length).toBe(1);
-      expect(result[0].name).toBe("clear");
-    });
-
-    it("returns matching commands for /s prefix", () => {
-      const result = getMatchingCommands("/s");
-      const names = result.map((cmd) => cmd.name);
-      expect(names).toContain("search");
-      expect(names).toContain("summarise");
-      expect(names).toContain("skill");
-    });
-
-    it("is case insensitive", () => {
-      const result1 = getMatchingCommands("/C");
-      const result2 = getMatchingCommands("/c");
-      expect(result1.length).toBe(result2.length);
-    });
-
-    it("returns empty array for no matches", () => {
-      const result = getMatchingCommands("/xyz");
-      expect(result).toEqual([]);
-    });
-
-    it("handles whitespace correctly", () => {
-      const result = getMatchingCommands("  /c");
-      const names = result.map((cmd) => cmd.name);
-      expect(names).toContain("cd");
-      expect(names).toContain("clear");
-    });
-
-    it("returns command for full command name", () => {
-      const result = getMatchingCommands("/help");
-      expect(result.length).toBe(1);
-      expect(result[0].name).toBe("help");
-    });
-
-    it("returns command for /new", () => {
-      const result = getMatchingCommands("/n");
-      expect(result.length).toBe(1);
-      expect(result[0].name).toBe("new");
-    });
-  });
-
-  describe("isSlashCommand", () => {
-    it("returns true for input starting with slash", () => {
-      expect(isSlashCommand("/cd")).toBe(true);
-      expect(isSlashCommand("/")).toBe(true);
-      expect(isSlashCommand("/help")).toBe(true);
-      expect(isSlashCommand("/unknown")).toBe(true);
-    });
-
-    it("returns false for non-slash input", () => {
-      expect(isSlashCommand("hello")).toBe(false);
-      expect(isSlashCommand("")).toBe(false);
-      expect(isSlashCommand("cd")).toBe(false);
-    });
-
-    it("handles whitespace correctly", () => {
-      expect(isSlashCommand("  /cd")).toBe(true);
-      expect(isSlashCommand("  hello")).toBe(false);
-    });
-
-    it("returns false for slash in middle of string", () => {
-      expect(isSlashCommand("hello/world")).toBe(false);
-    });
-  });
-
-  describe("SlashCommand interface", () => {
-    it("can create a valid slash command object", () => {
-      const testCommand: SlashCommand = {
-        name: "test",
-        description: "A test command",
-        usage: "/test [arg]",
-        execute: vi.fn(),
-      };
-
-      expect(testCommand.name).toBe("test");
-      expect(testCommand.description).toBe("A test command");
-      expect(testCommand.usage).toBe("/test [arg]");
-      expect(typeof testCommand.execute).toBe("function");
-    });
-
-    it("execute can be async function", () => {
-      const asyncCommand: SlashCommand = {
-        name: "async",
-        description: "An async command",
-        usage: "/async",
-        execute: async () => {
-          await Promise.resolve();
-        },
-      };
-
-      expect(asyncCommand.execute("")).toBeInstanceOf(Promise);
-    });
-
-    it("execute can be sync function", () => {
-      const syncCommand: SlashCommand = {
-        name: "sync",
-        description: "A sync command",
-        usage: "/sync",
-        execute: () => {
-          // Synchronous execution
-        },
-      };
-
-      const result = syncCommand.execute("");
-      // Sync function returns undefined, not a Promise
-      expect(result).toBeUndefined();
-    });
-  });
-});

src/lib/components/CompactMode.svelte

@@ -249,9 +249,6 @@
     -webkit-mask:
       linear-gradient(#fff 0 0) content-box,
       linear-gradient(#fff 0 0);
-    mask:
-      linear-gradient(#fff 0 0) content-box,
-      linear-gradient(#fff 0 0);
     -webkit-mask-composite: xor;
     mask-composite: exclude;
     opacity: 0;

src/lib/components/ConfigSidebar.svelte

@@ -3,9 +3,7 @@
     configStore,
     type HikariConfig,
     type Theme,
-    type CustomThemeColors,
     applyFontSize,
-    applyCustomThemeColors,
     MIN_FONT_SIZE,
     MAX_FONT_SIZE,
     DEFAULT_FONT_SIZE,
@@ -35,20 +33,8 @@
     profile_name: null,
     profile_avatar_path: null,
     profile_bio: null,
-    custom_theme_colors: {
-      bg_primary: null,
-      bg_secondary: null,
-      bg_terminal: null,
-      accent_primary: null,
-      accent_secondary: null,
-      text_primary: null,
-      text_secondary: null,
-      border_color: null,
-    },
   });
 
-  let showCustomThemeEditor = $state(false);
-
   let isOpen = $state(false);
   let isSaving = $state(false);
   let saveError: string | null = $state(null);
@@ -105,33 +91,9 @@
 
   async function handleThemeChange(theme: Theme) {
     config.theme = theme;
-    showCustomThemeEditor = theme === "custom";
+    await configStore.setTheme(theme);
-    await configStore.setTheme(theme, config.custom_theme_colors);
   }
 
-  function handleCustomColorChange(key: keyof CustomThemeColors, value: string) {
-    config.custom_theme_colors = {
-      ...config.custom_theme_colors,
-      [key]: value || null,
-    };
-    // Live preview
-    if (config.theme === "custom") {
-      applyCustomThemeColors(config.custom_theme_colors);
-    }
-  }
-
-  // Default dark theme colors for color picker defaults
-  const defaultDarkColors: Required<Record<keyof CustomThemeColors, string>> = {
-    bg_primary: "#1a1a2e",
-    bg_secondary: "#16213e",
-    bg_terminal: "#0f0f1a",
-    accent_primary: "#e94560",
-    accent_secondary: "#ff6b9d",
-    text_primary: "#ffffff",
-    text_secondary: "#a0a0a0",
-    border_color: "#2a2a4a",
-  };
-
   function toggleTool(tool: string) {
     if (config.auto_granted_tools.includes(tool)) {
       config.auto_granted_tools = config.auto_granted_tools.filter((t) => t !== tool);
@@ -458,12 +420,11 @@
 
       <!-- Theme Selection -->
       <div class="mb-4">
-        <span class="block text-sm text-[var(--text-secondary)] mb-2">Theme</span>
+        <label class="block text-sm text-[var(--text-secondary)] mb-2">Theme</label>
-        <div class="flex flex-wrap gap-2" role="group" aria-label="Theme selection">
+        <div class="flex gap-2">
           <button
             onclick={() => handleThemeChange("dark")}
-            class="flex-1 min-w-[70px] px-3 py-2 rounded-lg border transition-colors {config.theme ===
+            class="flex-1 px-3 py-2 rounded-lg border transition-colors {config.theme === 'dark'
-            'dark'
               ? 'bg-[var(--accent-primary)] border-[var(--accent-primary)] text-white'
               : 'bg-[var(--bg-primary)] border-[var(--border-color)] text-[var(--text-secondary)] hover:border-[var(--accent-primary)]'}"
           >
@@ -471,8 +432,7 @@
           </button>
           <button
             onclick={() => handleThemeChange("light")}
-            class="flex-1 min-w-[70px] px-3 py-2 rounded-lg border transition-colors {config.theme ===
+            class="flex-1 px-3 py-2 rounded-lg border transition-colors {config.theme === 'light'
-            'light'
               ? 'bg-[var(--accent-primary)] border-[var(--accent-primary)] text-white'
               : 'bg-[var(--bg-primary)] border-[var(--border-color)] text-[var(--text-secondary)] hover:border-[var(--accent-primary)]'}"
           >
@@ -480,178 +440,17 @@
           </button>
           <button
             onclick={() => handleThemeChange("high-contrast")}
-            class="flex-1 min-w-[70px] px-3 py-2 rounded-lg border transition-colors {config.theme ===
+            class="flex-1 px-3 py-2 rounded-lg border transition-colors {config.theme ===
             'high-contrast'
               ? 'bg-[var(--accent-primary)] border-[var(--accent-primary)] text-white'
               : 'bg-[var(--bg-primary)] border-[var(--border-color)] text-[var(--text-secondary)] hover:border-[var(--accent-primary)]'}"
             title="High contrast mode for improved accessibility"
           >
-            Contrast
+            High Contrast
-          </button>
-          <button
-            onclick={() => handleThemeChange("custom")}
-            class="flex-1 min-w-[70px] px-3 py-2 rounded-lg border transition-colors {config.theme ===
-            'custom'
-              ? 'bg-[var(--accent-primary)] border-[var(--accent-primary)] text-white'
-              : 'bg-[var(--bg-primary)] border-[var(--border-color)] text-[var(--text-secondary)] hover:border-[var(--accent-primary)]'}"
-            title="Create your own custom theme"
-          >
-            Custom
           </button>
         </div>
       </div>
 
-      <!-- Custom Theme Editor -->
-      {#if config.theme === "custom" || showCustomThemeEditor}
-        <div class="mb-4 p-3 bg-[var(--bg-primary)] rounded-lg border border-[var(--border-color)]">
-          <h4 class="text-sm font-medium text-[var(--text-primary)] mb-3">Custom Theme Colors</h4>
-          <div class="grid grid-cols-2 gap-3">
-            <div class="color-input-group">
-              <label class="text-xs text-[var(--text-secondary)]" for="color-bg-primary"
-                >Background</label
-              >
-              <div class="flex gap-2 items-center">
-                <input
-                  id="color-bg-primary"
-                  type="color"
-                  value={config.custom_theme_colors.bg_primary || defaultDarkColors.bg_primary}
-                  oninput={(e) => handleCustomColorChange("bg_primary", e.currentTarget.value)}
-                  class="color-picker"
-                />
-                <span class="text-xs text-[var(--text-tertiary)] font-mono">
-                  {config.custom_theme_colors.bg_primary || defaultDarkColors.bg_primary}
-                </span>
-              </div>
-            </div>
-            <div class="color-input-group">
-              <label class="text-xs text-[var(--text-secondary)]" for="color-bg-secondary"
-                >Secondary BG</label
-              >
-              <div class="flex gap-2 items-center">
-                <input
-                  id="color-bg-secondary"
-                  type="color"
-                  value={config.custom_theme_colors.bg_secondary || defaultDarkColors.bg_secondary}
-                  oninput={(e) => handleCustomColorChange("bg_secondary", e.currentTarget.value)}
-                  class="color-picker"
-                />
-                <span class="text-xs text-[var(--text-tertiary)] font-mono">
-                  {config.custom_theme_colors.bg_secondary || defaultDarkColors.bg_secondary}
-                </span>
-              </div>
-            </div>
-            <div class="color-input-group">
-              <label class="text-xs text-[var(--text-secondary)]" for="color-bg-terminal"
-                >Terminal BG</label
-              >
-              <div class="flex gap-2 items-center">
-                <input
-                  id="color-bg-terminal"
-                  type="color"
-                  value={config.custom_theme_colors.bg_terminal || defaultDarkColors.bg_terminal}
-                  oninput={(e) => handleCustomColorChange("bg_terminal", e.currentTarget.value)}
-                  class="color-picker"
-                />
-                <span class="text-xs text-[var(--text-tertiary)] font-mono">
-                  {config.custom_theme_colors.bg_terminal || defaultDarkColors.bg_terminal}
-                </span>
-              </div>
-            </div>
-            <div class="color-input-group">
-              <label class="text-xs text-[var(--text-secondary)]" for="color-border">Border</label>
-              <div class="flex gap-2 items-center">
-                <input
-                  id="color-border"
-                  type="color"
-                  value={config.custom_theme_colors.border_color || defaultDarkColors.border_color}
-                  oninput={(e) => handleCustomColorChange("border_color", e.currentTarget.value)}
-                  class="color-picker"
-                />
-                <span class="text-xs text-[var(--text-tertiary)] font-mono">
-                  {config.custom_theme_colors.border_color || defaultDarkColors.border_color}
-                </span>
-              </div>
-            </div>
-            <div class="color-input-group">
-              <label class="text-xs text-[var(--text-secondary)]" for="color-accent-primary"
-                >Accent Primary</label
-              >
-              <div class="flex gap-2 items-center">
-                <input
-                  id="color-accent-primary"
-                  type="color"
-                  value={config.custom_theme_colors.accent_primary ||
-                    defaultDarkColors.accent_primary}
-                  oninput={(e) => handleCustomColorChange("accent_primary", e.currentTarget.value)}
-                  class="color-picker"
-                />
-                <span class="text-xs text-[var(--text-tertiary)] font-mono">
-                  {config.custom_theme_colors.accent_primary || defaultDarkColors.accent_primary}
-                </span>
-              </div>
-            </div>
-            <div class="color-input-group">
-              <label class="text-xs text-[var(--text-secondary)]" for="color-accent-secondary"
-                >Accent Secondary</label
-              >
-              <div class="flex gap-2 items-center">
-                <input
-                  id="color-accent-secondary"
-                  type="color"
-                  value={config.custom_theme_colors.accent_secondary ||
-                    defaultDarkColors.accent_secondary}
-                  oninput={(e) =>
-                    handleCustomColorChange("accent_secondary", e.currentTarget.value)}
-                  class="color-picker"
-                />
-                <span class="text-xs text-[var(--text-tertiary)] font-mono">
-                  {config.custom_theme_colors.accent_secondary ||
-                    defaultDarkColors.accent_secondary}
-                </span>
-              </div>
-            </div>
-            <div class="color-input-group">
-              <label class="text-xs text-[var(--text-secondary)]" for="color-text-primary"
-                >Text Primary</label
-              >
-              <div class="flex gap-2 items-center">
-                <input
-                  id="color-text-primary"
-                  type="color"
-                  value={config.custom_theme_colors.text_primary || defaultDarkColors.text_primary}
-                  oninput={(e) => handleCustomColorChange("text_primary", e.currentTarget.value)}
-                  class="color-picker"
-                />
-                <span class="text-xs text-[var(--text-tertiary)] font-mono">
-                  {config.custom_theme_colors.text_primary || defaultDarkColors.text_primary}
-                </span>
-              </div>
-            </div>
-            <div class="color-input-group">
-              <label class="text-xs text-[var(--text-secondary)]" for="color-text-secondary"
-                >Text Secondary</label
-              >
-              <div class="flex gap-2 items-center">
-                <input
-                  id="color-text-secondary"
-                  type="color"
-                  value={config.custom_theme_colors.text_secondary ||
-                    defaultDarkColors.text_secondary}
-                  oninput={(e) => handleCustomColorChange("text_secondary", e.currentTarget.value)}
-                  class="color-picker"
-                />
-                <span class="text-xs text-[var(--text-tertiary)] font-mono">
-                  {config.custom_theme_colors.text_secondary || defaultDarkColors.text_secondary}
-                </span>
-              </div>
-            </div>
-          </div>
-          <p class="text-xs text-[var(--text-tertiary)] mt-3">
-            Changes preview live. Click Save Settings to persist.
-          </p>
-        </div>
-      {/if}
-
       <!-- Font Size -->
       <div class="mb-4">
         <label for="font-size" class="block text-sm text-[var(--text-secondary)] mb-2">
@@ -865,39 +664,4 @@
     background: var(--text-tertiary);
     cursor: not-allowed;
   }
-
-  /* Color picker styling */
-  .color-input-group {
-    display: flex;
-    flex-direction: column;
-    gap: 0.25rem;
-  }
-
-  .color-picker {
-    width: 32px;
-    height: 32px;
-    padding: 0;
-    border: 2px solid var(--border-color);
-    border-radius: 6px;
-    cursor: pointer;
-    background: transparent;
-  }
-
-  .color-picker::-webkit-color-swatch-wrapper {
-    padding: 2px;
-  }
-
-  .color-picker::-webkit-color-swatch {
-    border-radius: 4px;
-    border: none;
-  }
-
-  .color-picker::-moz-color-swatch {
-    border-radius: 4px;
-    border: none;
-  }
-
-  .color-picker:hover {
-    border-color: var(--accent-primary);
-  }
 </style>

src/lib/components/GitPanel.svelte

@@ -279,15 +279,8 @@
 <svelte:window on:keydown={handleKeydown} />
 
 {#if isOpen}
-  <!-- svelte-ignore a11y_click_events_have_key_events -->
   <div class="git-panel-overlay" on:click={onClose} role="presentation">
-    <div
+    <div class="git-panel" on:click|stopPropagation role="dialog" aria-label="Git Panel">
-      class="git-panel"
-      on:click|stopPropagation
-      role="dialog"
-      aria-label="Git Panel"
-      tabindex="-1"
-    >
       <div class="git-panel-header">
         <h2>🔀 Git</h2>
         <button class="close-btn" on:click={onClose} title="Close (Esc)">✕</button>
@@ -587,15 +580,8 @@
   </div>
 
   {#if showDiff}
-    <!-- svelte-ignore a11y_click_events_have_key_events -->
     <div class="diff-overlay" on:click={() => (showDiff = false)} role="presentation">
-      <div
+      <div class="diff-modal" on:click|stopPropagation role="dialog" aria-label="Diff View">
-        class="diff-modal"
-        on:click|stopPropagation
-        role="dialog"
-        aria-label="Diff View"
-        tabindex="-1"
-      >
         <div class="diff-header">
           <h3>📄 {diffFile}</h3>
           <button on:click={() => (showDiff = false)} title="Close">✕</button>
@@ -952,6 +938,10 @@
     cursor: pointer;
   }
 
+  .new-branch-input button:first-of-type {
+    /* Styling handled by btn-trans-gradient class */
+  }
+
   .new-branch-input button:last-of-type {
     background: var(--bg-tertiary);
     color: var(--text-primary);

src/lib/components/ProfilePanel.svelte

@@ -39,12 +39,11 @@
 
   let isGeneratingImage = false;
 
-  $: unlockedCount = Object.values($achievementsStore.achievements).filter(
+  $: unlockedCount = Object.values($achievementsStore.achievements).filter((a) => a.unlocked).length;
-    (a) => a.unlocked
-  ).length;
   $: totalAchievements = Object.values($achievementsStore.achievements).length;
-  $: achievementPercentage =
+  $: achievementPercentage = totalAchievements > 0
-    totalAchievements > 0 ? Math.round((unlockedCount / totalAchievements) * 100) : 0;
+    ? Math.round((unlockedCount / totalAchievements) * 100)
+    : 0;
 
   async function selectAvatar() {
     try {
@@ -83,15 +82,11 @@
   async function loadAvatarAsDataUrl(path: string): Promise<string | null> {
     try {
       const data = await readFile(path);
-      const extension = path.split(".").pop()?.toLowerCase() || "png";
+      const extension = path.split('.').pop()?.toLowerCase() || 'png';
-      const mimeType =
+      const mimeType = extension === 'jpg' || extension === 'jpeg' ? 'image/jpeg'
-        extension === "jpg" || extension === "jpeg"
+        : extension === 'gif' ? 'image/gif'
-          ? "image/jpeg"
+        : extension === 'webp' ? 'image/webp'
-          : extension === "gif"
+        : 'image/png';
-            ? "image/gif"
-            : extension === "webp"
-              ? "image/webp"
-              : "image/png";
       // Convert Uint8Array to base64 in chunks to avoid stack overflow
       const blob = new Blob([data], { type: mimeType });
       return new Promise((resolve) => {
@@ -128,7 +123,7 @@
     const stripeColors = ["#5bcefa", "#f5a9b8", "#ffffff", "#f5a9b8", "#5bcefa"];
     stripeColors.forEach((color, i) => {
       ctx.fillStyle = color;
-      ctx.fillRect(0, i * (stripeHeight / 5) * 2, width, (stripeHeight / 5) * 2);
+      ctx.fillRect(0, i * (stripeHeight / 5) * 2, width, stripeHeight / 5 * 2);
     });
 
     // Border
@@ -159,13 +154,7 @@
             img.onerror = () => reject();
             img.src = dataUrl;
           });
-          ctx.drawImage(
+          ctx.drawImage(img, avatarX - avatarRadius, avatarY - avatarRadius, avatarRadius * 2, avatarRadius * 2);
-            img,
-            avatarX - avatarRadius,
-            avatarY - avatarRadius,
-            avatarRadius * 2,
-            avatarRadius * 2
-          );
           avatarLoaded = true;
         }
       } catch {
@@ -174,22 +163,12 @@
     }
 
     if (!avatarLoaded) {
-      const avatarGradient = ctx.createLinearGradient(
+      const avatarGradient = ctx.createLinearGradient(avatarX - avatarRadius, avatarY - avatarRadius, avatarX + avatarRadius, avatarY + avatarRadius);
-        avatarX - avatarRadius,
-        avatarY - avatarRadius,
-        avatarX + avatarRadius,
-        avatarY + avatarRadius
-      );
       avatarGradient.addColorStop(0, "#5bcefa");
       avatarGradient.addColorStop(0.5, "#f5a9b8");
       avatarGradient.addColorStop(1, "#5bcefa");
       ctx.fillStyle = avatarGradient;
-      ctx.fillRect(
+      ctx.fillRect(avatarX - avatarRadius, avatarY - avatarRadius, avatarRadius * 2, avatarRadius * 2);
-        avatarX - avatarRadius,
-        avatarY - avatarRadius,
-        avatarRadius * 2,
-        avatarRadius * 2
-      );
     }
     ctx.restore();
 
@@ -281,23 +260,13 @@
     progressGradient.addColorStop(1, "#5bcefa");
     ctx.fillStyle = progressGradient;
     ctx.beginPath();
-    ctx.roundRect(
+    ctx.roundRect(progressX, progressY, progressWidth * (achievementPercentage / 100), progressHeight, 22);
-      progressX,
-      progressY,
-      progressWidth * (achievementPercentage / 100),
-      progressHeight,
-      22
-    );
     ctx.fill();
 
     // Progress text
     ctx.fillStyle = "#ffffff";
     ctx.font = "bold 36px system-ui, -apple-system, sans-serif";
-    ctx.fillText(
+    ctx.fillText(`${unlockedCount} / ${totalAchievements} (${achievementPercentage}%)`, progressX + progressWidth + 40, progressY + 34);
-      `${unlockedCount} / ${totalAchievements} (${achievementPercentage}%)`,
-      progressX + progressWidth + 40,
-      progressY + 34
-    );
 
     // Hikari branding
     ctx.fillStyle = "#f5a9b8";
@@ -343,14 +312,7 @@
     <div class="profile-header">
       <h2>Profile</h2>
       <button class="close-btn" on:click={onClose} aria-label="Close profile">
-        <svg
+        <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-          width="20"
-          height="20"
-          viewBox="0 0 24 24"
-          fill="none"
-          stroke="currentColor"
-          stroke-width="2"
-        >
           <path d="M18 6L6 18M6 6l12 12" />
         </svg>
       </button>
@@ -359,13 +321,7 @@
     <div class="profile-content">
       <!-- Avatar Section -->
       <div class="avatar-section">
-        <div
+        <div class="avatar-container" on:click={selectAvatar} role="button" tabindex="0" on:keydown={(e) => e.key === 'Enter' && selectAvatar()}>
-          class="avatar-container"
-          on:click={selectAvatar}
-          role="button"
-          tabindex="0"
-          on:keydown={(e) => e.key === "Enter" && selectAvatar()}
-        >
           {#if avatarDataUrl}
             <img src={avatarDataUrl} alt="Profile avatar" class="avatar-image" />
             <div class="avatar-overlay">
@@ -373,14 +329,7 @@
             </div>
           {:else}
             <div class="avatar-placeholder">
-              <svg
+              <svg width="48" height="48" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5">
-                width="48"
-                height="48"
-                viewBox="0 0 24 24"
-                fill="none"
-                stroke="currentColor"
-                stroke-width="1.5"
-              >
                 <path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2" />
                 <circle cx="12" cy="7" r="4" />
               </svg>
@@ -401,26 +350,13 @@
             bind:value={nameInput}
             placeholder="Enter your name"
             class="name-input"
-            on:keydown={(e) => e.key === "Enter" && saveName()}
+            on:keydown={(e) => e.key === 'Enter' && saveName()}
             on:blur={saveName}
           />
         {:else}
-          <button
+          <button class="name-display" on:click={() => { editingName = true; nameInput = config.profile_name || ""; }}>
-            class="name-display"
-            on:click={() => {
-              editingName = true;
-              nameInput = config.profile_name || "";
-            }}
-          >
             <span class="name-text">{config.profile_name || "Click to add name"}</span>
-            <svg
+            <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-              width="16"
-              height="16"
-              viewBox="0 0 24 24"
-              fill="none"
-              stroke="currentColor"
-              stroke-width="2"
-            >
               <path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7" />
               <path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z" />
             </svg>
@@ -441,13 +377,7 @@
           ></textarea>
           <button class="save-bio-btn btn-trans-gradient" on:click={saveBio}>Save</button>
         {:else}
-          <button
+          <button class="bio-display" on:click={() => { editingBio = true; bioInput = config.profile_bio || ""; }}>
-            class="bio-display"
-            on:click={() => {
-              editingBio = true;
-              bioInput = config.profile_bio || "";
-            }}
-          >
             <span class="bio-text">{config.profile_bio || "Click to add a bio..."}</span>
           </button>
         {/if}
@@ -491,31 +421,18 @@
           <div class="progress-bar">
             <div class="progress-fill" style="width: {achievementPercentage}%"></div>
           </div>
-          <span class="progress-text"
+          <span class="progress-text">{unlockedCount} / {totalAchievements} ({achievementPercentage}%)</span>
-            >{unlockedCount} / {totalAchievements} ({achievementPercentage}%)</span
-          >
         </div>
       </div>
 
       <!-- Share Section -->
       <div class="share-section">
-        <button
+        <button class="share-btn btn-trans-gradient" on:click={shareProfile} disabled={isGeneratingImage}>
-          class="share-btn btn-trans-gradient"
-          on:click={shareProfile}
-          disabled={isGeneratingImage}
-        >
           {#if isGeneratingImage}
             <span class="spinner"></span>
             Generating...
           {:else}
-            <svg
+            <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-              width="18"
-              height="18"
-              viewBox="0 0 24 24"
-              fill="none"
-              stroke="currentColor"
-              stroke-width="2"
-            >
               <path d="M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8" />
               <polyline points="16 6 12 2 8 6" />
               <line x1="12" y1="2" x2="12" y2="15" />
@@ -844,14 +761,7 @@
 
   .progress-fill {
     height: 100%;
-    background: linear-gradient(
+    background: linear-gradient(90deg, var(--trans-blue), var(--trans-pink), var(--trans-white), var(--trans-pink), var(--trans-blue));
-      90deg,
-      var(--trans-blue),
-      var(--trans-pink),
-      var(--trans-white),
-      var(--trans-pink),
-      var(--trans-blue)
-    );
     background-size: 200% 100%;
     animation: shimmer 3s linear infinite;
     border-radius: 6px;
@@ -859,12 +769,8 @@
   }
 
   @keyframes shimmer {
-    0% {
+    0% { background-position: 200% 0; }
-      background-position: 200% 0;
+    100% { background-position: -200% 0; }
-    }
-    100% {
-      background-position: -200% 0;
-    }
   }
 
   .progress-text {
@@ -922,8 +828,6 @@
   }
 
   @keyframes spin {
-    to {
+    to { transform: rotate(360deg); }
-      transform: rotate(360deg);
-    }
   }
 </style>

src/lib/components/QuickActionsPanel.svelte

@@ -449,7 +449,6 @@
   .line-clamp-2 {
     display: -webkit-box;
     -webkit-line-clamp: 2;
-    line-clamp: 2;
     -webkit-box-orient: vertical;
     overflow: hidden;
   }

src/lib/components/SessionHistoryPanel.svelte

@@ -469,7 +469,6 @@
   .line-clamp-2 {
     display: -webkit-box;
     -webkit-line-clamp: 2;
-    line-clamp: 2;
     -webkit-box-orient: vertical;
     overflow: hidden;
   }

src/lib/components/SnippetLibraryPanel.svelte

@@ -460,7 +460,6 @@
   .line-clamp-2 {
     display: -webkit-box;
     -webkit-line-clamp: 2;
-    line-clamp: 2;
     -webkit-box-orient: vertical;
     overflow: hidden;
   }

src/lib/components/StatsDisplay.svelte

@@ -119,6 +119,14 @@
     opacity: 0.8;
   }
 
+  .stat-highlight {
+    font-weight: 600;
+    color: var(--accent-primary);
+    margin-top: 0.25rem;
+    padding-top: 0.25rem;
+    border-top: 1px solid var(--border-color);
+  }
+
   .stat-label {
     color: var(--text-secondary, #9ca3af);
   }

src/lib/components/StatusBar.svelte

@@ -63,16 +63,6 @@
     profile_name: null,
     profile_avatar_path: null,
     profile_bio: null,
-    custom_theme_colors: {
-      bg_primary: null,
-      bg_secondary: null,
-      bg_terminal: null,
-      accent_primary: null,
-      accent_secondary: null,
-      text_primary: null,
-      text_secondary: null,
-      border_color: null,
-    },
   });
 
   let streamerModeActive = $state(false);

src/lib/components/UserQuestionModal.svelte

@@ -17,7 +17,7 @@
   hasQuestionPending.subscribe((pending) => {
     isVisible = pending;
     if (!pending) {
-      selectedOptions.clear();
+      selectedOptions = new SvelteSet();
       customAnswer = "";
       showCustomInput = false;
     }

src/lib/notifications/notifications.test.ts

@@ -1,329 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { NotificationType, NOTIFICATION_SOUNDS, type NotificationSound } from "./types";
-
-// Mock HTMLAudioElement for soundPlayer tests
-class MockAudioElement {
-  src: string = "";
-  preload: string = "";
-  volume: number = 1;
-
-  constructor(src?: string) {
-    if (src) this.src = src;
-  }
-
-  cloneNode(): MockAudioElement {
-    const clone = new MockAudioElement(this.src);
-    clone.volume = this.volume;
-    return clone;
-  }
-
-  async play(): Promise<void> {
-    return Promise.resolve();
-  }
-}
-
-// Store original Audio before mocking
-const OriginalAudio = globalThis.Audio;
-
-describe("notifications", () => {
-  describe("NotificationType enum", () => {
-    it("has SUCCESS type", () => {
-      expect(NotificationType.SUCCESS).toBe("success");
-    });
-
-    it("has ERROR type", () => {
-      expect(NotificationType.ERROR).toBe("error");
-    });
-
-    it("has PERMISSION type", () => {
-      expect(NotificationType.PERMISSION).toBe("permission");
-    });
-
-    it("has CONNECTION type", () => {
-      expect(NotificationType.CONNECTION).toBe("connection");
-    });
-
-    it("has TASK_START type", () => {
-      expect(NotificationType.TASK_START).toBe("task_start");
-    });
-
-    it("has ACHIEVEMENT type", () => {
-      expect(NotificationType.ACHIEVEMENT).toBe("achievement");
-    });
-
-    it("has exactly 6 notification types", () => {
-      const types = Object.values(NotificationType);
-      expect(types.length).toBe(6);
-    });
-  });
-
-  describe("NOTIFICATION_SOUNDS constant", () => {
-    it("has sounds for all notification types", () => {
-      Object.values(NotificationType).forEach((type) => {
-        expect(NOTIFICATION_SOUNDS[type]).toBeDefined();
-      });
-    });
-
-    it("each sound has required properties", () => {
-      Object.values(NOTIFICATION_SOUNDS).forEach((sound) => {
-        expect(sound.type).toBeDefined();
-        expect(sound.filename).toBeDefined();
-        expect(sound.phrase).toBeDefined();
-        expect(typeof sound.filename).toBe("string");
-        expect(typeof sound.phrase).toBe("string");
-        expect(sound.filename.endsWith(".mp3")).toBe(true);
-      });
-    });
-
-    it("SUCCESS sound has correct properties", () => {
-      const sound = NOTIFICATION_SOUNDS[NotificationType.SUCCESS];
-      expect(sound.type).toBe(NotificationType.SUCCESS);
-      expect(sound.filename).toBe("im-done.mp3");
-      expect(sound.phrase).toBe("I'm done!");
-      expect(sound.volume).toBe(0.7);
-    });
-
-    it("ERROR sound has correct properties", () => {
-      const sound = NOTIFICATION_SOUNDS[NotificationType.ERROR];
-      expect(sound.type).toBe(NotificationType.ERROR);
-      expect(sound.filename).toBe("oh-no.mp3");
-      expect(sound.phrase).toBe("Oh no...");
-      expect(sound.volume).toBe(0.8);
-    });
-
-    it("PERMISSION sound has correct properties", () => {
-      const sound = NOTIFICATION_SOUNDS[NotificationType.PERMISSION];
-      expect(sound.type).toBe(NotificationType.PERMISSION);
-      expect(sound.filename).toBe("access-please.mp3");
-      expect(sound.phrase).toBe("Access please!");
-      expect(sound.volume).toBe(0.9);
-    });
-
-    it("CONNECTION sound has correct properties", () => {
-      const sound = NOTIFICATION_SOUNDS[NotificationType.CONNECTION];
-      expect(sound.type).toBe(NotificationType.CONNECTION);
-      expect(sound.filename).toBe("connected.mp3");
-      expect(sound.phrase).toBe("Connected!");
-      expect(sound.volume).toBe(0.7);
-    });
-
-    it("TASK_START sound has correct properties", () => {
-      const sound = NOTIFICATION_SOUNDS[NotificationType.TASK_START];
-      expect(sound.type).toBe(NotificationType.TASK_START);
-      expect(sound.filename).toBe("working-on-it.mp3");
-      expect(sound.phrase).toBe("Working on it!");
-      expect(sound.volume).toBe(0.6);
-    });
-
-    it("ACHIEVEMENT sound has correct properties", () => {
-      const sound = NOTIFICATION_SOUNDS[NotificationType.ACHIEVEMENT];
-      expect(sound.type).toBe(NotificationType.ACHIEVEMENT);
-      expect(sound.filename).toBe("achievement.mp3");
-      expect(sound.phrase).toBe("Achievement Get~!");
-      expect(sound.volume).toBe(0.8);
-    });
-
-    it("all volumes are within valid range (0-1)", () => {
-      Object.values(NOTIFICATION_SOUNDS).forEach((sound) => {
-        if (sound.volume !== undefined) {
-          expect(sound.volume).toBeGreaterThanOrEqual(0);
-          expect(sound.volume).toBeLessThanOrEqual(1);
-        }
-      });
-    });
-  });
-
-  describe("NotificationSound interface", () => {
-    it("can create a valid notification sound object", () => {
-      const sound: NotificationSound = {
-        type: NotificationType.SUCCESS,
-        filename: "test-sound.mp3",
-        phrase: "Test phrase",
-        volume: 0.5,
-      };
-
-      expect(sound.type).toBe(NotificationType.SUCCESS);
-      expect(sound.filename).toBe("test-sound.mp3");
-      expect(sound.phrase).toBe("Test phrase");
-      expect(sound.volume).toBe(0.5);
-    });
-
-    it("volume is optional", () => {
-      const sound: NotificationSound = {
-        type: NotificationType.ERROR,
-        filename: "error.mp3",
-        phrase: "Error occurred",
-      };
-
-      expect(sound.volume).toBeUndefined();
-    });
-  });
-
-  describe("SoundPlayer class", () => {
-    beforeEach(() => {
-      // Mock Audio constructor
-      globalThis.Audio = MockAudioElement as unknown as typeof Audio;
-    });
-
-    afterEach(() => {
-      // Restore original Audio
-      globalThis.Audio = OriginalAudio;
-      vi.resetModules();
-    });
-
-    it("can import soundPlayer singleton", async () => {
-      const { soundPlayer } = await import("./soundPlayer");
-      expect(soundPlayer).toBeDefined();
-    });
-
-    it("setEnabled changes enabled state", async () => {
-      const { soundPlayer } = await import("./soundPlayer");
-
-      soundPlayer.setEnabled(true);
-      expect(soundPlayer.isEnabled()).toBe(true);
-
-      soundPlayer.setEnabled(false);
-      expect(soundPlayer.isEnabled()).toBe(false);
-    });
-
-    it("starts disabled by default", async () => {
-      // Need to reimport to get fresh instance behavior
-      // But since it's a singleton, we just test the method
-      const { soundPlayer } = await import("./soundPlayer");
-
-      // Reset to default state
-      soundPlayer.setEnabled(false);
-      expect(soundPlayer.isEnabled()).toBe(false);
-    });
-
-    it("setGlobalVolume clamps values to 0-1 range", async () => {
-      const { soundPlayer } = await import("./soundPlayer");
-
-      // Test that it doesn't throw on edge cases
-      soundPlayer.setGlobalVolume(0);
-      soundPlayer.setGlobalVolume(1);
-      soundPlayer.setGlobalVolume(0.5);
-
-      // Test clamping below 0
-      soundPlayer.setGlobalVolume(-0.5);
-
-      // Test clamping above 1
-      soundPlayer.setGlobalVolume(1.5);
-    });
-
-    it("play returns early when disabled", async () => {
-      const { soundPlayer } = await import("./soundPlayer");
-
-      soundPlayer.setEnabled(false);
-
-      // Should not throw when disabled
-      await expect(soundPlayer.play(NotificationType.SUCCESS)).resolves.toBeUndefined();
-    });
-
-    it("play attempts to play when enabled", async () => {
-      const { soundPlayer } = await import("./soundPlayer");
-
-      soundPlayer.setEnabled(true);
-
-      // Should not throw
-      await expect(soundPlayer.play(NotificationType.SUCCESS)).resolves.toBeUndefined();
-    });
-  });
-
-  describe("NotificationManager class", () => {
-    beforeEach(() => {
-      globalThis.Audio = MockAudioElement as unknown as typeof Audio;
-      vi.resetModules();
-    });
-
-    afterEach(() => {
-      globalThis.Audio = OriginalAudio;
-    });
-
-    it("can import notificationManager singleton", async () => {
-      vi.mock("@tauri-apps/api/core", () => ({
-        invoke: vi.fn().mockRejectedValue(new Error("Not available")),
-      }));
-
-      const { notificationManager } = await import("./notificationManager");
-      expect(notificationManager).toBeDefined();
-    });
-
-    it("has notifySuccess method", async () => {
-      vi.mock("@tauri-apps/api/core", () => ({
-        invoke: vi.fn().mockRejectedValue(new Error("Not available")),
-      }));
-
-      const { notificationManager } = await import("./notificationManager");
-      expect(typeof notificationManager.notifySuccess).toBe("function");
-    });
-
-    it("has notifyError method", async () => {
-      vi.mock("@tauri-apps/api/core", () => ({
-        invoke: vi.fn().mockRejectedValue(new Error("Not available")),
-      }));
-
-      const { notificationManager } = await import("./notificationManager");
-      expect(typeof notificationManager.notifyError).toBe("function");
-    });
-
-    it("has notifyPermission method", async () => {
-      vi.mock("@tauri-apps/api/core", () => ({
-        invoke: vi.fn().mockRejectedValue(new Error("Not available")),
-      }));
-
-      const { notificationManager } = await import("./notificationManager");
-      expect(typeof notificationManager.notifyPermission).toBe("function");
-    });
-
-    it("has notifyConnection method", async () => {
-      vi.mock("@tauri-apps/api/core", () => ({
-        invoke: vi.fn().mockRejectedValue(new Error("Not available")),
-      }));
-
-      const { notificationManager } = await import("./notificationManager");
-      expect(typeof notificationManager.notifyConnection).toBe("function");
-    });
-
-    it("has notifyTaskStart method", async () => {
-      vi.mock("@tauri-apps/api/core", () => ({
-        invoke: vi.fn().mockRejectedValue(new Error("Not available")),
-      }));
-
-      const { notificationManager } = await import("./notificationManager");
-      expect(typeof notificationManager.notifyTaskStart).toBe("function");
-    });
-
-    it("has notify method", async () => {
-      vi.mock("@tauri-apps/api/core", () => ({
-        invoke: vi.fn().mockRejectedValue(new Error("Not available")),
-      }));
-
-      const { notificationManager } = await import("./notificationManager");
-      expect(typeof notificationManager.notify).toBe("function");
-    });
-  });
-
-  describe("notification sounds file paths", () => {
-    it("all sound files have valid paths", () => {
-      Object.values(NOTIFICATION_SOUNDS).forEach((sound) => {
-        // Check that filename doesn't contain path traversal
-        expect(sound.filename).not.toContain("..");
-        expect(sound.filename).not.toContain("/");
-        expect(sound.filename).not.toContain("\\");
-      });
-    });
-
-    it("sound filenames are unique", () => {
-      const filenames = Object.values(NOTIFICATION_SOUNDS).map((s) => s.filename);
-      const uniqueFilenames = new Set(filenames);
-      expect(uniqueFilenames.size).toBe(filenames.length);
-    });
-
-    it("phrases are unique", () => {
-      const phrases = Object.values(NOTIFICATION_SOUNDS).map((s) => s.phrase);
-      const uniquePhrases = new Set(phrases);
-      expect(uniquePhrases.size).toBe(phrases.length);
-    });
-  });
-});

src/lib/stores/achievements.ts

@@ -1502,25 +1502,12 @@ export const achievementCategories = [
   {
     name: "Token Milestones",
     description: "Track your token generation progress",
-    ids: [
+    ids: ["FirstSteps", "GrowingStrong", "BlossomingCoder", "TokenMaster", "TokenBillionaire", "TokenTreasure"] as AchievementId[],
-      "FirstSteps",
-      "GrowingStrong",
-      "BlossomingCoder",
-      "TokenMaster",
-      "TokenBillionaire",
-      "TokenTreasure",
-    ] as AchievementId[],
   },
   {
     name: "Code Generation",
     description: "Achievements for generating code",
-    ids: [
+    ids: ["HelloWorld", "CodeWizard", "ThousandBlocks", "CodeFactory", "CodeEmpire"] as AchievementId[],
-      "HelloWorld",
-      "CodeWizard",
-      "ThousandBlocks",
-      "CodeFactory",
-      "CodeEmpire",
-    ] as AchievementId[],
   },
   {
     name: "File Operations",
@@ -1530,13 +1517,7 @@ export const achievementCategories = [
   {
     name: "Conversations",
     description: "Building our relationship through chat",
-    ids: [
+    ids: ["ConversationStarter", "ChattyKathy", "Conversationalist", "ChatMarathon", "ChatLegend"] as AchievementId[],
-      "ConversationStarter",
-      "ChattyKathy",
-      "Conversationalist",
-      "ChatMarathon",
-      "ChatLegend",
-    ] as AchievementId[],
   },
   {
     name: "Tools & Skills",
@@ -1575,16 +1556,7 @@ export const achievementCategories = [
   {
     name: "Relationship & Greetings",
     description: "Our special moments together",
-    ids: [
+    ids: ["GoodMorning", "GoodNight", "ThankYou", "LoveYou", "HelloHikari", "HowAreYou", "MissedYou", "BackAgain"] as AchievementId[],
-      "GoodMorning",
-      "GoodNight",
-      "ThankYou",
-      "LoveYou",
-      "HelloHikari",
-      "HowAreYou",
-      "MissedYou",
-      "BackAgain",
-    ] as AchievementId[],
   },
   {
     name: "Personality & Fun",
@@ -1599,16 +1571,7 @@ export const achievementCategories = [
   {
     name: "Git & Development",
     description: "Version control mastery",
-    ids: [
+    ids: ["GitGuru", "TestWriter", "Debugger", "CommitKing", "CommitLegend", "BranchMaster", "MergeExpert", "ConflictResolver"] as AchievementId[],
-      "GitGuru",
-      "TestWriter",
-      "Debugger",
-      "CommitKing",
-      "CommitLegend",
-      "BranchMaster",
-      "MergeExpert",
-      "ConflictResolver",
-    ] as AchievementId[],
   },
   {
     name: "Tool Mastery",
@@ -1643,41 +1606,17 @@ export const achievementCategories = [
   {
     name: "Seasonal",
     description: "Holiday coding!",
-    ids: [
+    ids: ["NewYearCoder", "ValentinesDev", "SpookyCode", "HolidayCoder", "LeapDayCoder"] as AchievementId[],
-      "NewYearCoder",
-      "ValentinesDev",
-      "SpookyCode",
-      "HolidayCoder",
-      "LeapDayCoder",
-    ] as AchievementId[],
   },
   {
     name: "Message Content",
     description: "How you communicate",
-    ids: [
+    ids: ["LongMessage", "NovelWriter", "ShortAndSweet", "CodeInMessage", "MarkdownMaster"] as AchievementId[],
-      "LongMessage",
-      "NovelWriter",
-      "ShortAndSweet",
-      "CodeInMessage",
-      "MarkdownMaster",
-    ] as AchievementId[],
   },
   {
     name: "Programming Languages",
     description: "Languages you've used",
-    ids: [
+    ids: ["RustDeveloper", "PythonDeveloper", "JavaScriptDev", "TypeScriptDev", "GoDeveloper", "CppDeveloper", "JavaDeveloper", "HtmlCssDev", "SqlDeveloper", "ShellScripter", "FullStackDev"] as AchievementId[],
-      "RustDeveloper",
-      "PythonDeveloper",
-      "JavaScriptDev",
-      "TypeScriptDev",
-      "GoDeveloper",
-      "CppDeveloper",
-      "JavaDeveloper",
-      "HtmlCssDev",
-      "SqlDeveloper",
-      "ShellScripter",
-      "FullStackDev",
-    ] as AchievementId[],
   },
   {
     name: "Project Types",
@@ -1722,23 +1661,12 @@ export const achievementCategories = [
   {
     name: "UI Exploration",
     description: "Explore Hikari's features",
-    ids: [
+    ids: ["MultiTasker", "Minimalist", "PrivacyFirst", "ThemeChanger", "SettingsTweaker"] as AchievementId[],
-      "MultiTasker",
-      "Minimalist",
-      "PrivacyFirst",
-      "ThemeChanger",
-      "SettingsTweaker",
-    ] as AchievementId[],
   },
   {
     name: "Achievement Meta",
     description: "Achievements about achievements",
-    ids: [
+    ids: ["AchievementHunter", "Completionist", "MasterUnlocker", "PlatinumStatus"] as AchievementId[],
-      "AchievementHunter",
-      "Completionist",
-      "MasterUnlocker",
-      "PlatinumStatus",
-    ] as AchievementId[],
   },
   {
     name: "Clipboard & Snippets",
@@ -1748,14 +1676,7 @@ export const achievementCategories = [
   {
     name: "Other Features",
     description: "Miscellaneous features",
-    ids: [
+    ids: ["QuickActionUser", "HistoryBuff", "Archivist", "SessionExporter", "GitPanelUser", "FeatureExplorer"] as AchievementId[],
-      "QuickActionUser",
-      "HistoryBuff",
-      "Archivist",
-      "SessionExporter",
-      "GitPanelUser",
-      "FeatureExplorer",
-    ] as AchievementId[],
   },
   {
     name: "Special",

src/lib/stores/config.test.ts

@@ -1,480 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import {
-  configStore,
-  maskPaths,
-  clampFontSize,
-  applyFontSize,
-  applyTheme,
-  applyCustomThemeColors,
-  clearCustomThemeColors,
-  MIN_FONT_SIZE,
-  MAX_FONT_SIZE,
-  DEFAULT_FONT_SIZE,
-  type HikariConfig,
-  type Theme,
-  type CustomThemeColors,
-} from "./config";
-
-// Mock Tauri APIs
-vi.mock("@tauri-apps/api/core", () => ({
-  invoke: vi.fn(),
-}));
-
-describe("config store", () => {
-  describe("font size constants", () => {
-    it("has correct MIN_FONT_SIZE", () => {
-      expect(MIN_FONT_SIZE).toBe(10);
-    });
-
-    it("has correct MAX_FONT_SIZE", () => {
-      expect(MAX_FONT_SIZE).toBe(24);
-    });
-
-    it("has correct DEFAULT_FONT_SIZE", () => {
-      expect(DEFAULT_FONT_SIZE).toBe(14);
-    });
-  });
-
-  describe("clampFontSize", () => {
-    it("returns the same value when within range", () => {
-      expect(clampFontSize(14)).toBe(14);
-      expect(clampFontSize(10)).toBe(10);
-      expect(clampFontSize(24)).toBe(24);
-      expect(clampFontSize(18)).toBe(18);
-    });
-
-    it("clamps values below minimum", () => {
-      expect(clampFontSize(5)).toBe(MIN_FONT_SIZE);
-      expect(clampFontSize(0)).toBe(MIN_FONT_SIZE);
-      expect(clampFontSize(-10)).toBe(MIN_FONT_SIZE);
-      expect(clampFontSize(9)).toBe(MIN_FONT_SIZE);
-    });
-
-    it("clamps values above maximum", () => {
-      expect(clampFontSize(30)).toBe(MAX_FONT_SIZE);
-      expect(clampFontSize(100)).toBe(MAX_FONT_SIZE);
-      expect(clampFontSize(25)).toBe(MAX_FONT_SIZE);
-    });
-  });
-
-  describe("maskPaths", () => {
-    it("returns text unchanged when hidePaths is false", () => {
-      const text = "/home/naomi/code/project/file.ts";
-      expect(maskPaths(text, false)).toBe(text);
-    });
-
-    it("masks Unix home paths", () => {
-      const text = "/home/naomi/code/project/file.ts";
-      expect(maskPaths(text, true)).toBe("/home/****/code/project/file.ts");
-    });
-
-    it("masks macOS user paths", () => {
-      const text = "/Users/naomi/Documents/project/file.ts";
-      expect(maskPaths(text, true)).toBe("/Users/****/Documents/project/file.ts");
-    });
-
-    it("masks Windows user paths", () => {
-      const text = "C:\\Users\\naomi\\Documents\\project\\file.ts";
-      expect(maskPaths(text, true)).toBe("C:\\Users\\****\\Documents\\project\\file.ts");
-    });
-
-    it("masks tilde paths", () => {
-      const text = "~/code/project/file.ts";
-      expect(maskPaths(text, true)).toBe("****/code/project/file.ts");
-    });
-
-    it("masks multiple paths in the same text", () => {
-      const text = "Editing /home/naomi/file1.ts and /home/naomi/file2.ts";
-      expect(maskPaths(text, true)).toBe("Editing /home/****/file1.ts and /home/****/file2.ts");
-    });
-
-    it("handles mixed path types", () => {
-      const text = "Unix: /home/user/file, Mac: /Users/user/file, Win: C:\\Users\\user\\file";
-      const expected = "Unix: /home/****/file, Mac: /Users/****/file, Win: C:\\Users\\****\\file";
-      expect(maskPaths(text, true)).toBe(expected);
-    });
-
-    it("handles paths with special characters in username", () => {
-      const text = "/home/user-name_123/project";
-      expect(maskPaths(text, true)).toBe("/home/****/project");
-    });
-
-    it("does not mask non-path text", () => {
-      const text = "This is just regular text without any paths";
-      expect(maskPaths(text, true)).toBe(text);
-    });
-
-    it("handles empty string", () => {
-      expect(maskPaths("", true)).toBe("");
-      expect(maskPaths("", false)).toBe("");
-    });
-  });
-
-  describe("Theme type", () => {
-    it("accepts valid theme values", () => {
-      const themes: Theme[] = ["dark", "light", "high-contrast", "custom"];
-      themes.forEach((theme) => {
-        expect(["dark", "light", "high-contrast", "custom"]).toContain(theme);
-      });
-    });
-  });
-
-  describe("CustomThemeColors interface", () => {
-    it("can create a valid custom theme colors object", () => {
-      const colors: CustomThemeColors = {
-        bg_primary: "#1a1a2e",
-        bg_secondary: "#16213e",
-        bg_terminal: "#0f0f23",
-        accent_primary: "#e94560",
-        accent_secondary: "#533483",
-        text_primary: "#eaeaea",
-        text_secondary: "#a0a0a0",
-        border_color: "#333355",
-      };
-
-      expect(colors.bg_primary).toBe("#1a1a2e");
-      expect(colors.accent_primary).toBe("#e94560");
-    });
-
-    it("allows null values for optional colors", () => {
-      const colors: CustomThemeColors = {
-        bg_primary: null,
-        bg_secondary: null,
-        bg_terminal: null,
-        accent_primary: "#e94560",
-        accent_secondary: null,
-        text_primary: null,
-        text_secondary: null,
-        border_color: null,
-      };
-
-      expect(colors.bg_primary).toBeNull();
-      expect(colors.accent_primary).toBe("#e94560");
-    });
-  });
-
-  describe("HikariConfig interface", () => {
-    it("can create a valid config object with all fields", () => {
-      const config: HikariConfig = {
-        model: "claude-sonnet-4",
-        api_key: "test-key",
-        custom_instructions: "Be helpful",
-        mcp_servers_json: "{}",
-        auto_granted_tools: ["Read", "Write"],
-        theme: "dark",
-        greeting_enabled: true,
-        greeting_custom_prompt: "Hello!",
-        notifications_enabled: true,
-        notification_volume: 0.7,
-        always_on_top: false,
-        minimize_to_tray: true,
-        update_checks_enabled: true,
-        character_panel_width: 300,
-        font_size: 14,
-        streamer_mode: false,
-        streamer_hide_paths: false,
-        compact_mode: false,
-        profile_name: "Naomi",
-        profile_avatar_path: "/path/to/avatar.png",
-        profile_bio: "Developer",
-        custom_theme_colors: {
-          bg_primary: null,
-          bg_secondary: null,
-          bg_terminal: null,
-          accent_primary: null,
-          accent_secondary: null,
-          text_primary: null,
-          text_secondary: null,
-          border_color: null,
-        },
-      };
-
-      expect(config.model).toBe("claude-sonnet-4");
-      expect(config.auto_granted_tools).toEqual(["Read", "Write"]);
-      expect(config.theme).toBe("dark");
-    });
-
-    it("allows null values for optional fields", () => {
-      const config: HikariConfig = {
-        model: null,
-        api_key: null,
-        custom_instructions: null,
-        mcp_servers_json: null,
-        auto_granted_tools: [],
-        theme: "dark",
-        greeting_enabled: true,
-        greeting_custom_prompt: null,
-        notifications_enabled: true,
-        notification_volume: 0.7,
-        always_on_top: false,
-        minimize_to_tray: false,
-        update_checks_enabled: true,
-        character_panel_width: null,
-        font_size: 14,
-        streamer_mode: false,
-        streamer_hide_paths: false,
-        compact_mode: false,
-        profile_name: null,
-        profile_avatar_path: null,
-        profile_bio: null,
-        custom_theme_colors: {
-          bg_primary: null,
-          bg_secondary: null,
-          bg_terminal: null,
-          accent_primary: null,
-          accent_secondary: null,
-          text_primary: null,
-          text_secondary: null,
-          border_color: null,
-        },
-      };
-
-      expect(config.model).toBeNull();
-      expect(config.api_key).toBeNull();
-      expect(config.character_panel_width).toBeNull();
-    });
-  });
-
-  describe("applyFontSize", () => {
-    beforeEach(() => {
-      // Reset document state
-      if (typeof document !== "undefined") {
-        document.documentElement.style.removeProperty("--terminal-font-size");
-      }
-    });
-
-    it("sets CSS variable for valid font size", () => {
-      applyFontSize(16);
-      const value = document.documentElement.style.getPropertyValue("--terminal-font-size");
-      expect(value).toBe("16px");
-    });
-
-    it("clamps font size below minimum", () => {
-      applyFontSize(5);
-      const value = document.documentElement.style.getPropertyValue("--terminal-font-size");
-      expect(value).toBe(`${MIN_FONT_SIZE}px`);
-    });
-
-    it("clamps font size above maximum", () => {
-      applyFontSize(50);
-      const value = document.documentElement.style.getPropertyValue("--terminal-font-size");
-      expect(value).toBe(`${MAX_FONT_SIZE}px`);
-    });
-  });
-
-  describe("applyTheme", () => {
-    beforeEach(() => {
-      // Reset document state
-      if (typeof document !== "undefined") {
-        document.documentElement.removeAttribute("data-theme");
-        clearCustomThemeColors();
-      }
-    });
-
-    it("sets data-theme attribute for dark theme", () => {
-      applyTheme("dark");
-      expect(document.documentElement.getAttribute("data-theme")).toBe("dark");
-    });
-
-    it("sets data-theme attribute for light theme", () => {
-      applyTheme("light");
-      expect(document.documentElement.getAttribute("data-theme")).toBe("light");
-    });
-
-    it("sets data-theme attribute for high-contrast theme", () => {
-      applyTheme("high-contrast");
-      expect(document.documentElement.getAttribute("data-theme")).toBe("high-contrast");
-    });
-
-    it("uses dark as base for custom theme", () => {
-      applyTheme("custom");
-      expect(document.documentElement.getAttribute("data-theme")).toBe("dark");
-    });
-
-    it("applies custom colors when theme is custom", () => {
-      const colors: CustomThemeColors = {
-        bg_primary: "#1a1a2e",
-        bg_secondary: null,
-        bg_terminal: null,
-        accent_primary: "#e94560",
-        accent_secondary: null,
-        text_primary: null,
-        text_secondary: null,
-        border_color: null,
-      };
-
-      applyTheme("custom", colors);
-
-      expect(document.documentElement.style.getPropertyValue("--bg-primary")).toBe("#1a1a2e");
-      expect(document.documentElement.style.getPropertyValue("--accent-primary")).toBe("#e94560");
-    });
-
-    it("does not apply custom colors for non-custom themes", () => {
-      const colors: CustomThemeColors = {
-        bg_primary: "#1a1a2e",
-        bg_secondary: null,
-        bg_terminal: null,
-        accent_primary: null,
-        accent_secondary: null,
-        text_primary: null,
-        text_secondary: null,
-        border_color: null,
-      };
-
-      applyTheme("dark", colors);
-
-      expect(document.documentElement.style.getPropertyValue("--bg-primary")).toBe("");
-    });
-  });
-
-  describe("applyCustomThemeColors", () => {
-    beforeEach(() => {
-      clearCustomThemeColors();
-    });
-
-    it("applies all provided colors", () => {
-      const colors: CustomThemeColors = {
-        bg_primary: "#111111",
-        bg_secondary: "#222222",
-        bg_terminal: "#333333",
-        accent_primary: "#444444",
-        accent_secondary: "#555555",
-        text_primary: "#666666",
-        text_secondary: "#777777",
-        border_color: "#888888",
-      };
-
-      applyCustomThemeColors(colors);
-
-      expect(document.documentElement.style.getPropertyValue("--bg-primary")).toBe("#111111");
-      expect(document.documentElement.style.getPropertyValue("--bg-secondary")).toBe("#222222");
-      expect(document.documentElement.style.getPropertyValue("--bg-terminal")).toBe("#333333");
-      expect(document.documentElement.style.getPropertyValue("--accent-primary")).toBe("#444444");
-      expect(document.documentElement.style.getPropertyValue("--accent-secondary")).toBe("#555555");
-      expect(document.documentElement.style.getPropertyValue("--text-primary")).toBe("#666666");
-      expect(document.documentElement.style.getPropertyValue("--text-secondary")).toBe("#777777");
-      expect(document.documentElement.style.getPropertyValue("--border-color")).toBe("#888888");
-    });
-
-    it("skips null values", () => {
-      const colors: CustomThemeColors = {
-        bg_primary: "#111111",
-        bg_secondary: null,
-        bg_terminal: null,
-        accent_primary: null,
-        accent_secondary: null,
-        text_primary: null,
-        text_secondary: null,
-        border_color: null,
-      };
-
-      applyCustomThemeColors(colors);
-
-      expect(document.documentElement.style.getPropertyValue("--bg-primary")).toBe("#111111");
-      expect(document.documentElement.style.getPropertyValue("--bg-secondary")).toBe("");
-    });
-  });
-
-  describe("clearCustomThemeColors", () => {
-    it("removes all custom theme CSS properties", () => {
-      // First apply some colors
-      const colors: CustomThemeColors = {
-        bg_primary: "#111111",
-        bg_secondary: "#222222",
-        bg_terminal: "#333333",
-        accent_primary: "#444444",
-        accent_secondary: "#555555",
-        text_primary: "#666666",
-        text_secondary: "#777777",
-        border_color: "#888888",
-      };
-      applyCustomThemeColors(colors);
-
-      // Then clear them
-      clearCustomThemeColors();
-
-      expect(document.documentElement.style.getPropertyValue("--bg-primary")).toBe("");
-      expect(document.documentElement.style.getPropertyValue("--bg-secondary")).toBe("");
-      expect(document.documentElement.style.getPropertyValue("--bg-terminal")).toBe("");
-      expect(document.documentElement.style.getPropertyValue("--accent-primary")).toBe("");
-      expect(document.documentElement.style.getPropertyValue("--accent-secondary")).toBe("");
-      expect(document.documentElement.style.getPropertyValue("--text-primary")).toBe("");
-      expect(document.documentElement.style.getPropertyValue("--text-secondary")).toBe("");
-      expect(document.documentElement.style.getPropertyValue("--border-color")).toBe("");
-    });
-  });
-
-  describe("derived stores", () => {
-    // Note: These tests verify the derived store logic by testing the derivation functions
-    // The actual stores depend on configStore which requires Tauri invoke mocking
-
-    it("isDarkTheme returns true for dark theme config", () => {
-      // Test the derivation logic
-      const darkConfig = { theme: "dark" as Theme };
-      expect(darkConfig.theme === "dark").toBe(true);
-    });
-
-    it("isDarkTheme returns false for light theme config", () => {
-      const lightConfig = { theme: "light" as Theme };
-      expect(lightConfig.theme === "dark").toBe(false);
-    });
-
-    it("isStreamerMode derives from streamer_mode config", () => {
-      const configWithStreamerMode = { streamer_mode: true };
-      const configWithoutStreamerMode = { streamer_mode: false };
-
-      expect(configWithStreamerMode.streamer_mode).toBe(true);
-      expect(configWithoutStreamerMode.streamer_mode).toBe(false);
-    });
-
-    it("isCompactMode derives from compact_mode config", () => {
-      const configWithCompactMode = { compact_mode: true };
-      const configWithoutCompactMode = { compact_mode: false };
-
-      expect(configWithCompactMode.compact_mode).toBe(true);
-      expect(configWithoutCompactMode.compact_mode).toBe(false);
-    });
-
-    it("shouldHidePaths requires both streamer_mode and streamer_hide_paths", () => {
-      const config1 = { streamer_mode: true, streamer_hide_paths: true };
-      const config2 = { streamer_mode: true, streamer_hide_paths: false };
-      const config3 = { streamer_mode: false, streamer_hide_paths: true };
-      const config4 = { streamer_mode: false, streamer_hide_paths: false };
-
-      expect(config1.streamer_mode && config1.streamer_hide_paths).toBe(true);
-      expect(config2.streamer_mode && config2.streamer_hide_paths).toBe(false);
-      expect(config3.streamer_mode && config3.streamer_hide_paths).toBe(false);
-      expect(config4.streamer_mode && config4.streamer_hide_paths).toBe(false);
-    });
-  });
-
-  describe("configStore methods", () => {
-    it("has all expected methods", () => {
-      expect(typeof configStore.loadConfig).toBe("function");
-      expect(typeof configStore.saveConfig).toBe("function");
-      expect(typeof configStore.updateConfig).toBe("function");
-      expect(typeof configStore.openSidebar).toBe("function");
-      expect(typeof configStore.closeSidebar).toBe("function");
-      expect(typeof configStore.toggleSidebar).toBe("function");
-      expect(typeof configStore.setTheme).toBe("function");
-      expect(typeof configStore.setCustomThemeColors).toBe("function");
-      expect(typeof configStore.setFontSize).toBe("function");
-      expect(typeof configStore.increaseFontSize).toBe("function");
-      expect(typeof configStore.decreaseFontSize).toBe("function");
-      expect(typeof configStore.resetFontSize).toBe("function");
-      expect(typeof configStore.addAutoGrantedTool).toBe("function");
-      expect(typeof configStore.removeAutoGrantedTool).toBe("function");
-      expect(typeof configStore.getConfig).toBe("function");
-      expect(typeof configStore.toggleStreamerMode).toBe("function");
-      expect(typeof configStore.toggleCompactMode).toBe("function");
-      expect(typeof configStore.setCompactMode).toBe("function");
-    });
-
-    it("has subscribable stores", () => {
-      expect(typeof configStore.config.subscribe).toBe("function");
-      expect(typeof configStore.isLoading.subscribe).toBe("function");
-      expect(typeof configStore.isSidebarOpen.subscribe).toBe("function");
-      expect(typeof configStore.saveError.subscribe).toBe("function");
-    });
-  });
-});

src/lib/stores/config.ts

@@ -1,18 +1,7 @@
 import { writable, derived } from "svelte/store";
 import { invoke } from "@tauri-apps/api/core";
 
-export type Theme = "dark" | "light" | "high-contrast" | "custom";
+export type Theme = "dark" | "light" | "high-contrast";
-
-export interface CustomThemeColors {
-  bg_primary: string | null;
-  bg_secondary: string | null;
-  bg_terminal: string | null;
-  accent_primary: string | null;
-  accent_secondary: string | null;
-  text_primary: string | null;
-  text_secondary: string | null;
-  border_color: string | null;
-}
 
 export interface HikariConfig {
   model: string | null;
@@ -36,7 +25,6 @@ export interface HikariConfig {
   profile_name: string | null;
   profile_avatar_path: string | null;
   profile_bio: string | null;
-  custom_theme_colors: CustomThemeColors;
 }
 
 const defaultConfig: HikariConfig = {
@@ -61,16 +49,6 @@ const defaultConfig: HikariConfig = {
   profile_name: null,
   profile_avatar_path: null,
   profile_bio: null,
-  custom_theme_colors: {
-    bg_primary: null,
-    bg_secondary: null,
-    bg_terminal: null,
-    accent_primary: null,
-    accent_secondary: null,
-    text_primary: null,
-    text_secondary: null,
-    border_color: null,
-  },
 };
 
 function createConfigStore() {
@@ -126,24 +104,9 @@ function createConfigStore() {
     closeSidebar: () => isSidebarOpen.set(false),
     toggleSidebar: () => isSidebarOpen.update((open) => !open),
 
-    setTheme: async (theme: Theme, customColors?: CustomThemeColors) => {
+    setTheme: async (theme: Theme) => {
-      const updates: Partial<HikariConfig> = { theme };
+      await updateConfig({ theme });
-      if (customColors) {
+      applyTheme(theme);
-        updates.custom_theme_colors = customColors;
-      }
-      await updateConfig(updates);
-      let currentConfig: HikariConfig = defaultConfig;
-      config.subscribe((c) => (currentConfig = c))();
-      applyTheme(theme, currentConfig.custom_theme_colors);
-    },
-
-    setCustomThemeColors: async (colors: CustomThemeColors) => {
-      await updateConfig({ custom_theme_colors: colors });
-      let currentConfig: HikariConfig = defaultConfig;
-      config.subscribe((c) => (currentConfig = c))();
-      if (currentConfig.theme === "custom") {
-        applyCustomThemeColors(colors);
-      }
     },
 
     setFontSize: async (size: number) => {
@@ -213,53 +176,12 @@ function createConfigStore() {
   };
 }
 
-export function applyTheme(theme: Theme, customColors?: CustomThemeColors) {
+export function applyTheme(theme: Theme) {
   if (typeof document !== "undefined") {
-    // For custom theme, we use dark as the base and override with custom colors
+    document.documentElement.setAttribute("data-theme", theme);
-    document.documentElement.setAttribute("data-theme", theme === "custom" ? "dark" : theme);
-
-    // Clear any previously applied custom colors
-    clearCustomThemeColors();
-
-    // Apply custom colors if theme is custom
-    if (theme === "custom" && customColors) {
-      applyCustomThemeColors(customColors);
-    }
   }
 }
 
-export function applyCustomThemeColors(colors: CustomThemeColors) {
-  if (typeof document === "undefined") return;
-
-  const root = document.documentElement;
-  if (colors.bg_primary) root.style.setProperty("--bg-primary", colors.bg_primary);
-  if (colors.bg_secondary) root.style.setProperty("--bg-secondary", colors.bg_secondary);
-  if (colors.bg_terminal) root.style.setProperty("--bg-terminal", colors.bg_terminal);
-  if (colors.accent_primary) root.style.setProperty("--accent-primary", colors.accent_primary);
-  if (colors.accent_secondary)
-    root.style.setProperty("--accent-secondary", colors.accent_secondary);
-  if (colors.text_primary) root.style.setProperty("--text-primary", colors.text_primary);
-  if (colors.text_secondary) root.style.setProperty("--text-secondary", colors.text_secondary);
-  if (colors.border_color) root.style.setProperty("--border-color", colors.border_color);
-}
-
-export function clearCustomThemeColors() {
-  if (typeof document === "undefined") return;
-
-  const root = document.documentElement;
-  const customProperties = [
-    "--bg-primary",
-    "--bg-secondary",
-    "--bg-terminal",
-    "--accent-primary",
-    "--accent-secondary",
-    "--text-primary",
-    "--text-secondary",
-    "--border-color",
-  ];
-  customProperties.forEach((prop) => root.style.removeProperty(prop));
-}
-
 const MIN_FONT_SIZE = 10;
 const MAX_FONT_SIZE = 24;
 const DEFAULT_FONT_SIZE = 14;

src/lib/stores/conversations.test.ts

@@ -1,525 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-// Test the Conversation interface and store behavior
-describe("Conversation interface", () => {
-  it("defines all required fields", () => {
-    const conversation = {
-      id: "conv-123",
-      name: "Test Conversation",
-      terminalLines: [],
-      sessionId: null,
-      connectionStatus: "disconnected" as const,
-      workingDirectory: "",
-      characterState: "idle" as const,
-      isProcessing: false,
-      grantedTools: new Set<string>(),
-      pendingPermission: null,
-      pendingQuestion: null,
-      scrollPosition: -1,
-      createdAt: new Date(),
-      lastActivityAt: new Date(),
-      attachments: [],
-    };
-
-    expect(conversation.id).toBe("conv-123");
-    expect(conversation.name).toBe("Test Conversation");
-    expect(conversation.terminalLines).toEqual([]);
-    expect(conversation.sessionId).toBeNull();
-    expect(conversation.connectionStatus).toBe("disconnected");
-    expect(conversation.workingDirectory).toBe("");
-    expect(conversation.characterState).toBe("idle");
-    expect(conversation.isProcessing).toBe(false);
-    expect(conversation.grantedTools.size).toBe(0);
-    expect(conversation.pendingPermission).toBeNull();
-    expect(conversation.pendingQuestion).toBeNull();
-    expect(conversation.scrollPosition).toBe(-1);
-    expect(conversation.attachments).toEqual([]);
-  });
-
-  it("handles terminal lines array", () => {
-    const lines = [
-      {
-        id: "line-1",
-        type: "user" as const,
-        content: "Hello",
-        timestamp: new Date(),
-      },
-      {
-        id: "line-2",
-        type: "assistant" as const,
-        content: "Hi there!",
-        timestamp: new Date(),
-      },
-    ];
-
-    expect(lines).toHaveLength(2);
-    expect(lines[0].type).toBe("user");
-    expect(lines[1].type).toBe("assistant");
-  });
-});
-
-describe("conversation ID generation", () => {
-  it("generates unique IDs with timestamp prefix", () => {
-    let counter = 0;
-    const generateId = () => `conv-${Date.now()}-${counter++}`;
-
-    const id1 = generateId();
-    const id2 = generateId();
-
-    expect(id1).toMatch(/^conv-\d+-\d+$/);
-    expect(id2).toMatch(/^conv-\d+-\d+$/);
-    expect(id1).not.toBe(id2);
-  });
-});
-
-describe("line ID generation", () => {
-  it("generates unique line IDs", () => {
-    let counter = 0;
-    const generateLineId = () => `line-${Date.now()}-${counter++}`;
-
-    const id1 = generateLineId();
-    const id2 = generateLineId();
-
-    expect(id1).toMatch(/^line-\d+-\d+$/);
-    expect(id2).toMatch(/^line-\d+-\d+$/);
-    expect(id1).not.toBe(id2);
-  });
-});
-
-describe("connection status types", () => {
-  it("supports all connection status values", () => {
-    const statuses = ["connected", "disconnected", "connecting", "error"] as const;
-
-    statuses.forEach((status) => {
-      expect(typeof status).toBe("string");
-    });
-  });
-});
-
-describe("character state types", () => {
-  it("supports all character state values", () => {
-    const states = [
-      "idle",
-      "thinking",
-      "typing",
-      "searching",
-      "coding",
-      "mcp",
-      "permission",
-      "success",
-      "error",
-    ] as const;
-
-    states.forEach((state) => {
-      expect(typeof state).toBe("string");
-    });
-  });
-});
-
-describe("terminal line types", () => {
-  it("supports all terminal line types", () => {
-    const types = ["user", "assistant", "system", "tool", "error"] as const;
-
-    types.forEach((type) => {
-      expect(typeof type).toBe("string");
-    });
-  });
-
-  it("creates terminal line with required fields", () => {
-    const line = {
-      id: "line-123",
-      type: "user" as const,
-      content: "Test message",
-      timestamp: new Date(),
-      toolName: undefined,
-    };
-
-    expect(line.id).toBe("line-123");
-    expect(line.type).toBe("user");
-    expect(line.content).toBe("Test message");
-    expect(line.timestamp).toBeInstanceOf(Date);
-    expect(line.toolName).toBeUndefined();
-  });
-
-  it("creates terminal line with tool name", () => {
-    const line = {
-      id: "line-456",
-      type: "tool" as const,
-      content: "Tool output",
-      timestamp: new Date(),
-      toolName: "Read",
-    };
-
-    expect(line.toolName).toBe("Read");
-  });
-});
-
-describe("permission request structure", () => {
-  it("creates valid permission request", () => {
-    const request = {
-      id: "perm-123",
-      tool: "Bash",
-      description: "Run shell command",
-      input: '{"command": "ls"}',
-    };
-
-    expect(request.id).toBe("perm-123");
-    expect(request.tool).toBe("Bash");
-    expect(request.description).toBe("Run shell command");
-    expect(request.input).toContain("command");
-  });
-});
-
-describe("user question structure", () => {
-  it("creates valid question event", () => {
-    const question = {
-      id: "q-123",
-      question: "Which option?",
-      options: [
-        { label: "A", description: "Option A" },
-        { label: "B", description: "Option B" },
-      ],
-      conversation_id: "conv-123",
-    };
-
-    expect(question.id).toBe("q-123");
-    expect(question.question).toBe("Which option?");
-    expect(question.options).toHaveLength(2);
-  });
-});
-
-describe("attachment structure", () => {
-  it("creates valid file attachment", () => {
-    const attachment = {
-      id: "att-123",
-      type: "file" as const,
-      name: "test.txt",
-      path: "/tmp/test.txt",
-      size: 1024,
-      mimeType: "text/plain",
-    };
-
-    expect(attachment.id).toBe("att-123");
-    expect(attachment.type).toBe("file");
-    expect(attachment.name).toBe("test.txt");
-  });
-
-  it("creates valid image attachment", () => {
-    const attachment = {
-      id: "att-456",
-      type: "image" as const,
-      name: "screenshot.png",
-      path: "/tmp/screenshot.png",
-      size: 50000,
-      mimeType: "image/png",
-      previewUrl: "data:image/png;base64,...",
-    };
-
-    expect(attachment.type).toBe("image");
-    expect(attachment.previewUrl).toContain("data:image");
-  });
-});
-
-describe("conversation management operations", () => {
-  it("creates new conversation with default values", () => {
-    let counter = 1;
-    const createNewConversation = (name?: string) => {
-      const id = `conv-${Date.now()}-${counter++}`;
-      return {
-        id,
-        name: name || `Conversation ${counter}`,
-        terminalLines: [],
-        sessionId: null,
-        connectionStatus: "disconnected" as const,
-        workingDirectory: "",
-        characterState: "idle" as const,
-        isProcessing: false,
-        grantedTools: new Set<string>(),
-        pendingPermission: null,
-        pendingQuestion: null,
-        scrollPosition: -1,
-        createdAt: new Date(),
-        lastActivityAt: new Date(),
-        attachments: [],
-      };
-    };
-
-    const conv = createNewConversation("My Chat");
-    expect(conv.name).toBe("My Chat");
-    expect(conv.connectionStatus).toBe("disconnected");
-    expect(conv.characterState).toBe("idle");
-  });
-
-  it("uses default name when not provided", () => {
-    const counter = 5;
-    const createNewConversation = (name?: string) => ({
-      name: name || `Conversation ${counter}`,
-    });
-
-    const conv = createNewConversation();
-    expect(conv.name).toBe("Conversation 5");
-  });
-});
-
-describe("conversation history formatting", () => {
-  it("formats user and assistant messages for history", () => {
-    const lines = [
-      { type: "user" as const, content: "Hello" },
-      { type: "assistant" as const, content: "Hi there!" },
-      { type: "system" as const, content: "Connected" },
-      { type: "user" as const, content: "How are you?" },
-    ];
-
-    const relevantLines = lines.filter((line) => line.type === "user" || line.type === "assistant");
-
-    const history = relevantLines
-      .map((line) => {
-        const role = line.type === "user" ? "User" : "Assistant";
-        return `${role}: ${line.content}`;
-      })
-      .join("\n\n");
-
-    expect(history).toContain("User: Hello");
-    expect(history).toContain("Assistant: Hi there!");
-    expect(history).toContain("User: How are you?");
-    expect(history).not.toContain("Connected");
-  });
-
-  it("returns empty string for no messages", () => {
-    const lines: Array<{ type: string; content: string }> = [];
-    const relevantLines = lines.filter((line) => line.type === "user" || line.type === "assistant");
-
-    expect(relevantLines.length).toBe(0);
-    const history = relevantLines.length === 0 ? "" : "has content";
-    expect(history).toBe("");
-  });
-});
-
-describe("tool granting", () => {
-  it("tracks granted tools with Set", () => {
-    const grantedTools = new Set<string>();
-
-    grantedTools.add("Read");
-    grantedTools.add("Write");
-    grantedTools.add("Bash");
-
-    expect(grantedTools.has("Read")).toBe(true);
-    expect(grantedTools.has("Write")).toBe(true);
-    expect(grantedTools.has("Bash")).toBe(true);
-    expect(grantedTools.has("Edit")).toBe(false);
-    expect(grantedTools.size).toBe(3);
-  });
-
-  it("clears all granted tools", () => {
-    const grantedTools = new Set<string>(["Read", "Write"]);
-    expect(grantedTools.size).toBe(2);
-
-    grantedTools.clear();
-    expect(grantedTools.size).toBe(0);
-  });
-});
-
-describe("scroll position handling", () => {
-  it("uses -1 for auto-scroll (scroll to bottom)", () => {
-    const scrollPosition = -1;
-    const isAutoScroll = scrollPosition === -1;
-
-    expect(isAutoScroll).toBe(true);
-  });
-
-  it("uses positive values for manual scroll position", () => {
-    const scrollPosition: number = 500;
-    const isAutoScroll = scrollPosition === -1;
-
-    expect(isAutoScroll).toBe(false);
-    expect(scrollPosition).toBeGreaterThan(0);
-  });
-});
-
-describe("conversation deletion rules", () => {
-  it("prevents deletion of last conversation", () => {
-    const conversations = new Map([["conv-1", { id: "conv-1", name: "Main" }]]);
-
-    const canDelete = conversations.size > 1;
-    expect(canDelete).toBe(false);
-  });
-
-  it("allows deletion when multiple conversations exist", () => {
-    const conversations = new Map([
-      ["conv-1", { id: "conv-1", name: "Main" }],
-      ["conv-2", { id: "conv-2", name: "Second" }],
-    ]);
-
-    const canDelete = conversations.size > 1;
-    expect(canDelete).toBe(true);
-  });
-
-  it("switches to remaining conversation after deletion", () => {
-    const conversations = new Map([
-      ["conv-1", { id: "conv-1", name: "Main" }],
-      ["conv-2", { id: "conv-2", name: "Second" }],
-    ]);
-
-    const activeId = "conv-1";
-    conversations.delete(activeId);
-
-    const remaining = Array.from(conversations.keys());
-    expect(remaining).toEqual(["conv-2"]);
-    expect(remaining[0]).toBe("conv-2");
-  });
-});
-
-describe("activity timestamp tracking", () => {
-  it("updates lastActivityAt on changes", () => {
-    const before = new Date();
-
-    // Simulate a small delay
-    const after = new Date(before.getTime() + 100);
-
-    expect(after.getTime()).toBeGreaterThan(before.getTime());
-  });
-});
-
-describe("Map operations for conversations", () => {
-  it("stores and retrieves conversations by ID", () => {
-    const conversations = new Map<string, { id: string; name: string }>();
-
-    conversations.set("conv-1", { id: "conv-1", name: "First" });
-    conversations.set("conv-2", { id: "conv-2", name: "Second" });
-
-    expect(conversations.get("conv-1")?.name).toBe("First");
-    expect(conversations.get("conv-2")?.name).toBe("Second");
-    expect(conversations.get("conv-3")).toBeUndefined();
-  });
-
-  it("checks if conversation exists", () => {
-    const conversations = new Map([["conv-1", { id: "conv-1" }]]);
-
-    expect(conversations.has("conv-1")).toBe(true);
-    expect(conversations.has("conv-2")).toBe(false);
-  });
-
-  it("iterates over all conversations", () => {
-    const conversations = new Map([
-      ["conv-1", { id: "conv-1", name: "First" }],
-      ["conv-2", { id: "conv-2", name: "Second" }],
-    ]);
-
-    const names: string[] = [];
-    conversations.forEach((conv) => names.push(conv.name));
-
-    expect(names).toContain("First");
-    expect(names).toContain("Second");
-  });
-});
-
-describe("conversation rename", () => {
-  it("updates conversation name", () => {
-    const conversation = { id: "conv-1", name: "Old Name", lastActivityAt: new Date() };
-
-    conversation.name = "New Name";
-    conversation.lastActivityAt = new Date();
-
-    expect(conversation.name).toBe("New Name");
-  });
-});
-
-describe("attachment management", () => {
-  it("adds attachment to array", () => {
-    const attachments: Array<{ id: string; name: string }> = [];
-
-    attachments.push({ id: "att-1", name: "file1.txt" });
-    expect(attachments).toHaveLength(1);
-
-    attachments.push({ id: "att-2", name: "file2.txt" });
-    expect(attachments).toHaveLength(2);
-  });
-
-  it("removes attachment by ID", () => {
-    const attachments = [
-      { id: "att-1", name: "file1.txt" },
-      { id: "att-2", name: "file2.txt" },
-    ];
-
-    const filtered = attachments.filter((a) => a.id !== "att-1");
-    expect(filtered).toHaveLength(1);
-    expect(filtered[0].id).toBe("att-2");
-  });
-
-  it("clears all attachments", () => {
-    const cleared: Array<{ id: string }> = [];
-    expect(cleared).toHaveLength(0);
-  });
-});
-
-describe("derived store behavior", () => {
-  it("derives connection status from active conversation", () => {
-    const activeConv = { connectionStatus: "connected" as const };
-    const derivedStatus = activeConv?.connectionStatus || "disconnected";
-
-    expect(derivedStatus).toBe("connected");
-  });
-
-  it("defaults to disconnected when no active conversation", () => {
-    const activeConv = null as { connectionStatus?: string } | null;
-    const derivedStatus = activeConv?.connectionStatus || "disconnected";
-
-    expect(derivedStatus).toBe("disconnected");
-  });
-
-  it("derives terminal lines from active conversation", () => {
-    const activeConv = {
-      terminalLines: [
-        { id: "1", content: "Hello" },
-        { id: "2", content: "World" },
-      ],
-    };
-    const derivedLines = activeConv?.terminalLines || [];
-
-    expect(derivedLines).toHaveLength(2);
-  });
-
-  it("defaults to empty array when no active conversation", () => {
-    const activeConv = null as { terminalLines?: Array<{ id: string; content: string }> } | null;
-    const derivedLines = activeConv?.terminalLines || [];
-
-    expect(derivedLines).toEqual([]);
-  });
-});
-
-describe("line update operations", () => {
-  it("updates line content by ID", () => {
-    const lines = [
-      { id: "line-1", content: "Original" },
-      { id: "line-2", content: "Other" },
-    ];
-
-    const line = lines.find((l) => l.id === "line-1");
-    if (line) {
-      line.content = "Updated";
-    }
-
-    expect(lines[0].content).toBe("Updated");
-    expect(lines[1].content).toBe("Other");
-  });
-
-  it("appends to line content", () => {
-    const line = { id: "line-1", content: "Hello" };
-
-    line.content += " World";
-
-    expect(line.content).toBe("Hello World");
-  });
-});
-
-describe("pending retry message", () => {
-  it("stores and clears retry message", () => {
-    let pendingRetryMessage: string | null = null;
-
-    pendingRetryMessage = "Retry this message";
-    expect(pendingRetryMessage).toBe("Retry this message");
-
-    pendingRetryMessage = null;
-    expect(pendingRetryMessage).toBeNull();
-  });
-});

src/lib/stores/quickActions.test.ts

@@ -1,351 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { invoke } from "@tauri-apps/api/core";
-import { setMockInvokeResult } from "../../../vitest.setup";
-import { quickActionsStore, type QuickAction } from "./quickActions";
-
-describe("QuickAction interface", () => {
-  it("defines all required fields", () => {
-    const action: QuickAction = {
-      id: "action-123",
-      name: "Run Tests",
-      prompt: "Please run the tests",
-      icon: "play",
-      is_default: false,
-      created_at: "2024-01-01T00:00:00Z",
-      updated_at: "2024-01-01T00:00:00Z",
-    };
-
-    expect(action.id).toBe("action-123");
-    expect(action.name).toBe("Run Tests");
-    expect(action.prompt).toBe("Please run the tests");
-    expect(action.icon).toBe("play");
-    expect(action.is_default).toBe(false);
-    expect(action.created_at).toBe("2024-01-01T00:00:00Z");
-    expect(action.updated_at).toBe("2024-01-01T00:00:00Z");
-  });
-
-  it("supports default actions", () => {
-    const defaultAction: QuickAction = {
-      id: "default-review-pr",
-      name: "Review PR",
-      prompt: "Please review this pull request",
-      icon: "git-pull-request",
-      is_default: true,
-      created_at: "2024-01-01T00:00:00Z",
-      updated_at: "2024-01-01T00:00:00Z",
-    };
-
-    expect(defaultAction.is_default).toBe(true);
-    expect(defaultAction.id).toContain("default-");
-  });
-});
-
-describe("quickActionsStore", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("store structure", () => {
-    it("has all expected methods", () => {
-      expect(typeof quickActionsStore.loadQuickActions).toBe("function");
-      expect(typeof quickActionsStore.saveQuickAction).toBe("function");
-      expect(typeof quickActionsStore.createQuickAction).toBe("function");
-      expect(typeof quickActionsStore.updateQuickAction).toBe("function");
-      expect(typeof quickActionsStore.deleteQuickAction).toBe("function");
-      expect(typeof quickActionsStore.resetDefaults).toBe("function");
-    });
-
-    it("has subscribable stores", () => {
-      expect(typeof quickActionsStore.actions.subscribe).toBe("function");
-      expect(typeof quickActionsStore.isLoading.subscribe).toBe("function");
-    });
-  });
-
-  describe("loadQuickActions", () => {
-    it("loads quick actions from backend", async () => {
-      const mockActions: QuickAction[] = [
-        {
-          id: "action-1",
-          name: "Action 1",
-          prompt: "prompt 1",
-          icon: "star",
-          is_default: false,
-          created_at: "2024-01-01T00:00:00Z",
-          updated_at: "2024-01-01T00:00:00Z",
-        },
-      ];
-
-      setMockInvokeResult("list_quick_actions", mockActions);
-
-      await quickActionsStore.loadQuickActions();
-
-      expect(invoke).toHaveBeenCalledWith("list_quick_actions");
-    });
-
-    it("handles load errors gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("list_quick_actions", new Error("Failed to load"));
-
-      await quickActionsStore.loadQuickActions();
-
-      expect(consoleSpy).toHaveBeenCalledWith("Failed to load quick actions:", expect.any(Error));
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("saveQuickAction", () => {
-    it("saves action and reloads list", async () => {
-      const action: QuickAction = {
-        id: "action-123",
-        name: "Test",
-        prompt: "test prompt",
-        icon: "star",
-        is_default: false,
-        created_at: "2024-01-01T00:00:00Z",
-        updated_at: "2024-01-01T00:00:00Z",
-      };
-
-      setMockInvokeResult("save_quick_action", undefined);
-      setMockInvokeResult("list_quick_actions", [action]);
-
-      const result = await quickActionsStore.saveQuickAction(action);
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith("save_quick_action", { action });
-    });
-
-    it("handles save errors gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("save_quick_action", new Error("Failed to save"));
-
-      const action: QuickAction = {
-        id: "action-123",
-        name: "Test",
-        prompt: "test prompt",
-        icon: "star",
-        is_default: false,
-        created_at: "2024-01-01T00:00:00Z",
-        updated_at: "2024-01-01T00:00:00Z",
-      };
-
-      const result = await quickActionsStore.saveQuickAction(action);
-
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith("Failed to save quick action:", expect.any(Error));
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("createQuickAction", () => {
-    it("creates new action with generated ID and timestamps", async () => {
-      setMockInvokeResult("save_quick_action", undefined);
-      setMockInvokeResult("list_quick_actions", []);
-
-      const result = await quickActionsStore.createQuickAction("My Action", "Do something", "star");
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith(
-        "save_quick_action",
-        expect.objectContaining({
-          action: expect.objectContaining({
-            name: "My Action",
-            prompt: "Do something",
-            icon: "star",
-            is_default: false,
-          }),
-        })
-      );
-    });
-  });
-
-  describe("updateQuickAction", () => {
-    it("updates existing action preserving created_at", async () => {
-      const existingAction: QuickAction = {
-        id: "action-123",
-        name: "Old Name",
-        prompt: "old prompt",
-        icon: "old-icon",
-        is_default: false,
-        created_at: "2024-01-01T00:00:00Z",
-        updated_at: "2024-01-01T00:00:00Z",
-      };
-
-      setMockInvokeResult("list_quick_actions", [existingAction]);
-      setMockInvokeResult("save_quick_action", undefined);
-
-      const result = await quickActionsStore.updateQuickAction(
-        "action-123",
-        "New Name",
-        "new prompt",
-        "new-icon"
-      );
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith(
-        "save_quick_action",
-        expect.objectContaining({
-          action: expect.objectContaining({
-            id: "action-123",
-            name: "New Name",
-            prompt: "new prompt",
-            icon: "new-icon",
-            created_at: "2024-01-01T00:00:00Z",
-          }),
-        })
-      );
-    });
-
-    it("returns false for non-existent action", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("list_quick_actions", []);
-
-      const result = await quickActionsStore.updateQuickAction(
-        "non-existent",
-        "Name",
-        "prompt",
-        "icon"
-      );
-
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith("Quick action not found for update");
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("deleteQuickAction", () => {
-    it("deletes action by ID", async () => {
-      setMockInvokeResult("delete_quick_action", undefined);
-      setMockInvokeResult("list_quick_actions", []);
-
-      const result = await quickActionsStore.deleteQuickAction("action-123");
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith("delete_quick_action", { actionId: "action-123" });
-    });
-
-    it("handles delete errors gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("delete_quick_action", new Error("Cannot delete default action"));
-
-      const result = await quickActionsStore.deleteQuickAction("default-1");
-
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith("Failed to delete quick action:", expect.any(Error));
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("resetDefaults", () => {
-    it("resets default actions", async () => {
-      setMockInvokeResult("reset_default_quick_actions", undefined);
-      setMockInvokeResult("list_quick_actions", []);
-
-      const result = await quickActionsStore.resetDefaults();
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith("reset_default_quick_actions");
-    });
-
-    it("handles reset errors gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("reset_default_quick_actions", new Error("Reset failed"));
-
-      const result = await quickActionsStore.resetDefaults();
-
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith(
-        "Failed to reset default quick actions:",
-        expect.any(Error)
-      );
-      consoleSpy.mockRestore();
-    });
-  });
-});
-
-describe("quick action ID generation", () => {
-  it("generates unique custom action IDs", () => {
-    const generateId = () => `custom-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-
-    const id1 = generateId();
-    const id2 = generateId();
-
-    expect(id1).toMatch(/^custom-\d+-[a-z0-9]+$/);
-    expect(id2).toMatch(/^custom-\d+-[a-z0-9]+$/);
-    expect(id1).not.toBe(id2);
-  });
-});
-
-describe("action validation", () => {
-  it("requires non-empty name", () => {
-    const action = { name: "" };
-    const isValid = action.name.trim().length > 0;
-    expect(isValid).toBe(false);
-  });
-
-  it("requires non-empty prompt", () => {
-    const action = { prompt: "   " };
-    const isValid = action.prompt.trim().length > 0;
-    expect(isValid).toBe(false);
-  });
-
-  it("requires non-empty icon", () => {
-    const action = { icon: "star" };
-    const isValid = action.icon.trim().length > 0;
-    expect(isValid).toBe(true);
-  });
-});
-
-describe("action icons", () => {
-  it("supports various icon names", () => {
-    const validIcons = [
-      "git-pull-request",
-      "play",
-      "file-text",
-      "alert-circle",
-      "check-square",
-      "refresh-cw",
-      "star",
-      "code",
-      "terminal",
-    ];
-
-    validIcons.forEach((icon) => {
-      expect(typeof icon).toBe("string");
-      expect(icon.length).toBeGreaterThan(0);
-    });
-  });
-});
-
-describe("action sorting", () => {
-  it("sorts default actions before custom actions", () => {
-    const actions = [
-      { id: "custom-1", name: "Custom", is_default: false },
-      { id: "default-1", name: "Default", is_default: true },
-    ];
-
-    const sorted = [...actions].sort((a, b) => {
-      const defaultCmp = (b.is_default ? 1 : 0) - (a.is_default ? 1 : 0);
-      if (defaultCmp !== 0) return defaultCmp;
-      return a.name.localeCompare(b.name);
-    });
-
-    expect(sorted[0].is_default).toBe(true);
-    expect(sorted[1].is_default).toBe(false);
-  });
-
-  it("sorts alphabetically within same default status", () => {
-    const actions = [
-      { id: "default-2", name: "Zebra", is_default: true },
-      { id: "default-1", name: "Apple", is_default: true },
-    ];
-
-    const sorted = [...actions].sort((a, b) => {
-      const defaultCmp = (b.is_default ? 1 : 0) - (a.is_default ? 1 : 0);
-      if (defaultCmp !== 0) return defaultCmp;
-      return a.name.localeCompare(b.name);
-    });
-
-    expect(sorted[0].name).toBe("Apple");
-    expect(sorted[1].name).toBe("Zebra");
-  });
-});

src/lib/stores/snippets.test.ts

@@ -1,353 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { get } from "svelte/store";
-import { invoke } from "@tauri-apps/api/core";
-import { setMockInvokeResult } from "../../../vitest.setup";
-import { snippetsStore, type Snippet } from "./snippets";
-
-describe("Snippet interface", () => {
-  it("defines all required fields", () => {
-    const snippet: Snippet = {
-      id: "snippet-123",
-      name: "Git Status",
-      content: "git status",
-      category: "Git",
-      is_default: false,
-      created_at: "2024-01-01T00:00:00Z",
-      updated_at: "2024-01-01T00:00:00Z",
-    };
-
-    expect(snippet.id).toBe("snippet-123");
-    expect(snippet.name).toBe("Git Status");
-    expect(snippet.content).toBe("git status");
-    expect(snippet.category).toBe("Git");
-    expect(snippet.is_default).toBe(false);
-    expect(snippet.created_at).toBe("2024-01-01T00:00:00Z");
-    expect(snippet.updated_at).toBe("2024-01-01T00:00:00Z");
-  });
-
-  it("supports default snippets", () => {
-    const defaultSnippet: Snippet = {
-      id: "default-git-status",
-      name: "Git Status",
-      content: "git status --short",
-      category: "Git",
-      is_default: true,
-      created_at: "2024-01-01T00:00:00Z",
-      updated_at: "2024-01-01T00:00:00Z",
-    };
-
-    expect(defaultSnippet.is_default).toBe(true);
-  });
-});
-
-describe("snippetsStore", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("store structure", () => {
-    it("has all expected methods", () => {
-      expect(typeof snippetsStore.loadSnippets).toBe("function");
-      expect(typeof snippetsStore.saveSnippet).toBe("function");
-      expect(typeof snippetsStore.createSnippet).toBe("function");
-      expect(typeof snippetsStore.updateSnippet).toBe("function");
-      expect(typeof snippetsStore.deleteSnippet).toBe("function");
-      expect(typeof snippetsStore.resetDefaults).toBe("function");
-      expect(typeof snippetsStore.setSelectedCategory).toBe("function");
-    });
-
-    it("has subscribable stores", () => {
-      expect(typeof snippetsStore.snippets.subscribe).toBe("function");
-      expect(typeof snippetsStore.categories.subscribe).toBe("function");
-      expect(typeof snippetsStore.filteredSnippets.subscribe).toBe("function");
-      expect(typeof snippetsStore.isLoading.subscribe).toBe("function");
-      expect(typeof snippetsStore.selectedCategory.subscribe).toBe("function");
-    });
-  });
-
-  describe("loadSnippets", () => {
-    it("loads snippets and categories from backend", async () => {
-      const mockSnippets: Snippet[] = [
-        {
-          id: "snippet-1",
-          name: "Snippet 1",
-          content: "content 1",
-          category: "Git",
-          is_default: false,
-          created_at: "2024-01-01T00:00:00Z",
-          updated_at: "2024-01-01T00:00:00Z",
-        },
-      ];
-      const mockCategories = ["Git", "Shell", "Docker"];
-
-      setMockInvokeResult("list_snippets", mockSnippets);
-      setMockInvokeResult("get_snippet_categories", mockCategories);
-
-      await snippetsStore.loadSnippets();
-
-      expect(invoke).toHaveBeenCalledWith("list_snippets");
-      expect(invoke).toHaveBeenCalledWith("get_snippet_categories");
-    });
-
-    it("handles load errors gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("list_snippets", new Error("Failed to load"));
-
-      await snippetsStore.loadSnippets();
-
-      expect(consoleSpy).toHaveBeenCalledWith("Failed to load snippets:", expect.any(Error));
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("saveSnippet", () => {
-    it("saves snippet and reloads list", async () => {
-      const snippet: Snippet = {
-        id: "snippet-123",
-        name: "Test",
-        content: "test content",
-        category: "Test",
-        is_default: false,
-        created_at: "2024-01-01T00:00:00Z",
-        updated_at: "2024-01-01T00:00:00Z",
-      };
-
-      setMockInvokeResult("save_snippet", undefined);
-      setMockInvokeResult("list_snippets", [snippet]);
-      setMockInvokeResult("get_snippet_categories", ["Test"]);
-
-      const result = await snippetsStore.saveSnippet(snippet);
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith("save_snippet", { snippet });
-    });
-
-    it("handles save errors gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("save_snippet", new Error("Failed to save"));
-
-      const snippet: Snippet = {
-        id: "snippet-123",
-        name: "Test",
-        content: "test content",
-        category: "Test",
-        is_default: false,
-        created_at: "2024-01-01T00:00:00Z",
-        updated_at: "2024-01-01T00:00:00Z",
-      };
-
-      const result = await snippetsStore.saveSnippet(snippet);
-
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith("Failed to save snippet:", expect.any(Error));
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("createSnippet", () => {
-    it("creates new snippet with generated ID and timestamps", async () => {
-      setMockInvokeResult("save_snippet", undefined);
-      setMockInvokeResult("list_snippets", []);
-      setMockInvokeResult("get_snippet_categories", ["Shell"]);
-
-      const result = await snippetsStore.createSnippet("My Snippet", "echo hello", "Shell");
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith(
-        "save_snippet",
-        expect.objectContaining({
-          snippet: expect.objectContaining({
-            name: "My Snippet",
-            content: "echo hello",
-            category: "Shell",
-            is_default: false,
-          }),
-        })
-      );
-    });
-  });
-
-  describe("updateSnippet", () => {
-    it("updates existing snippet preserving created_at", async () => {
-      const existingSnippet: Snippet = {
-        id: "snippet-123",
-        name: "Old Name",
-        content: "old content",
-        category: "Old Category",
-        is_default: false,
-        created_at: "2024-01-01T00:00:00Z",
-        updated_at: "2024-01-01T00:00:00Z",
-      };
-
-      setMockInvokeResult("list_snippets", [existingSnippet]);
-      setMockInvokeResult("save_snippet", undefined);
-      setMockInvokeResult("get_snippet_categories", ["New Category"]);
-
-      const result = await snippetsStore.updateSnippet(
-        "snippet-123",
-        "New Name",
-        "new content",
-        "New Category"
-      );
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith(
-        "save_snippet",
-        expect.objectContaining({
-          snippet: expect.objectContaining({
-            id: "snippet-123",
-            name: "New Name",
-            content: "new content",
-            category: "New Category",
-            created_at: "2024-01-01T00:00:00Z",
-          }),
-        })
-      );
-    });
-
-    it("returns false for non-existent snippet", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("list_snippets", []);
-
-      const result = await snippetsStore.updateSnippet(
-        "non-existent",
-        "Name",
-        "content",
-        "Category"
-      );
-
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith("Snippet not found for update");
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("deleteSnippet", () => {
-    it("deletes snippet by ID", async () => {
-      setMockInvokeResult("delete_snippet", undefined);
-      setMockInvokeResult("list_snippets", []);
-      setMockInvokeResult("get_snippet_categories", []);
-
-      const result = await snippetsStore.deleteSnippet("snippet-123");
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith("delete_snippet", { snippetId: "snippet-123" });
-    });
-
-    it("handles delete errors gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("delete_snippet", new Error("Cannot delete default snippet"));
-
-      const result = await snippetsStore.deleteSnippet("default-1");
-
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith("Failed to delete snippet:", expect.any(Error));
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("resetDefaults", () => {
-    it("resets default snippets", async () => {
-      setMockInvokeResult("reset_default_snippets", undefined);
-      setMockInvokeResult("list_snippets", []);
-      setMockInvokeResult("get_snippet_categories", []);
-
-      const result = await snippetsStore.resetDefaults();
-
-      expect(result).toBe(true);
-      expect(invoke).toHaveBeenCalledWith("reset_default_snippets");
-    });
-
-    it("handles reset errors gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      setMockInvokeResult("reset_default_snippets", new Error("Reset failed"));
-
-      const result = await snippetsStore.resetDefaults();
-
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith(
-        "Failed to reset default snippets:",
-        expect.any(Error)
-      );
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe("setSelectedCategory", () => {
-    it("updates selected category", () => {
-      snippetsStore.setSelectedCategory("Git");
-      expect(get(snippetsStore.selectedCategory)).toBe("Git");
-    });
-
-    it("can be cleared with null", () => {
-      snippetsStore.setSelectedCategory("Git");
-      snippetsStore.setSelectedCategory(null);
-      expect(get(snippetsStore.selectedCategory)).toBeNull();
-    });
-  });
-});
-
-describe("snippet ID generation", () => {
-  it("generates unique custom snippet IDs", () => {
-    const generateId = () => `custom-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-
-    const id1 = generateId();
-    const id2 = generateId();
-
-    expect(id1).toMatch(/^custom-\d+-[a-z0-9]+$/);
-    expect(id2).toMatch(/^custom-\d+-[a-z0-9]+$/);
-    expect(id1).not.toBe(id2);
-  });
-});
-
-describe("snippet validation", () => {
-  it("requires non-empty name", () => {
-    const snippet = { name: "" };
-    const isValid = snippet.name.trim().length > 0;
-    expect(isValid).toBe(false);
-  });
-
-  it("requires non-empty content", () => {
-    const snippet = { content: "   " };
-    const isValid = snippet.content.trim().length > 0;
-    expect(isValid).toBe(false);
-  });
-
-  it("requires non-empty category", () => {
-    const snippet = { category: "Git" };
-    const isValid = snippet.category.trim().length > 0;
-    expect(isValid).toBe(true);
-  });
-});
-
-describe("snippet content types", () => {
-  it("supports multiline content", () => {
-    const snippet = {
-      content: `git add .
-git commit -m "message"
-git push`,
-    };
-
-    expect(snippet.content.includes("\n")).toBe(true);
-    expect(snippet.content.split("\n")).toHaveLength(3);
-  });
-
-  it("supports content with special characters", () => {
-    const snippet = {
-      content: "echo \"Hello, World!\" && echo 'Single quotes'",
-    };
-
-    expect(snippet.content).toContain('"');
-    expect(snippet.content).toContain("'");
-    expect(snippet.content).toContain("&&");
-  });
-
-  it("supports content with variables", () => {
-    const snippet = {
-      content: "docker run -v $PWD:/app ${IMAGE_NAME}:${TAG}",
-    };
-
-    expect(snippet.content).toContain("$PWD");
-    expect(snippet.content).toContain("${IMAGE_NAME}");
-  });
-});

src/lib/stores/stats.test.ts

@@ -1,346 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { get } from "svelte/store";
-import { stats, formattedStats, resetSessionStats } from "./stats";
-import type { UsageStats } from "./stats";
-
-// Mock Tauri APIs
-vi.mock("@tauri-apps/api/event", () => ({
-  listen: vi.fn(),
-}));
-
-vi.mock("@tauri-apps/api/core", () => ({
-  invoke: vi.fn(),
-}));
-
-describe("stats store", () => {
-  beforeEach(() => {
-    // Reset stats to default before each test
-    stats.set({
-      total_input_tokens: 0,
-      total_output_tokens: 0,
-      total_cost_usd: 0,
-      session_input_tokens: 0,
-      session_output_tokens: 0,
-      session_cost_usd: 0,
-      model: null,
-      messages_exchanged: 0,
-      session_messages_exchanged: 0,
-      code_blocks_generated: 0,
-      session_code_blocks_generated: 0,
-      files_edited: 0,
-      session_files_edited: 0,
-      files_created: 0,
-      session_files_created: 0,
-      tools_usage: {},
-      session_tools_usage: {},
-      session_duration_seconds: 0,
-    });
-  });
-
-  describe("stats writable store", () => {
-    it("has correct default values", () => {
-      const currentStats = get(stats);
-      expect(currentStats.total_input_tokens).toBe(0);
-      expect(currentStats.total_output_tokens).toBe(0);
-      expect(currentStats.total_cost_usd).toBe(0);
-      expect(currentStats.model).toBeNull();
-    });
-
-    it("can be updated with set", () => {
-      const newStats: UsageStats = {
-        total_input_tokens: 1000,
-        total_output_tokens: 2000,
-        total_cost_usd: 0.05,
-        session_input_tokens: 500,
-        session_output_tokens: 1000,
-        session_cost_usd: 0.025,
-        model: "claude-sonnet-4",
-        messages_exchanged: 10,
-        session_messages_exchanged: 5,
-        code_blocks_generated: 3,
-        session_code_blocks_generated: 2,
-        files_edited: 5,
-        session_files_edited: 2,
-        files_created: 1,
-        session_files_created: 1,
-        tools_usage: { Read: 5, Edit: 3 },
-        session_tools_usage: { Read: 2, Edit: 1 },
-        session_duration_seconds: 300,
-      };
-
-      stats.set(newStats);
-      const currentStats = get(stats);
-
-      expect(currentStats.total_input_tokens).toBe(1000);
-      expect(currentStats.total_output_tokens).toBe(2000);
-      expect(currentStats.model).toBe("claude-sonnet-4");
-      expect(currentStats.tools_usage).toEqual({ Read: 5, Edit: 3 });
-    });
-
-    it("can be updated with update function", () => {
-      stats.update((current) => ({
-        ...current,
-        total_input_tokens: 500,
-        session_messages_exchanged: 3,
-      }));
-
-      const currentStats = get(stats);
-      expect(currentStats.total_input_tokens).toBe(500);
-      expect(currentStats.session_messages_exchanged).toBe(3);
-    });
-  });
-
-  describe("resetSessionStats", () => {
-    it("resets all session fields to zero", () => {
-      // First set some values
-      stats.set({
-        total_input_tokens: 1000,
-        total_output_tokens: 2000,
-        total_cost_usd: 0.05,
-        session_input_tokens: 500,
-        session_output_tokens: 1000,
-        session_cost_usd: 0.025,
-        model: "claude-sonnet-4",
-        messages_exchanged: 10,
-        session_messages_exchanged: 5,
-        code_blocks_generated: 3,
-        session_code_blocks_generated: 2,
-        files_edited: 5,
-        session_files_edited: 2,
-        files_created: 1,
-        session_files_created: 1,
-        tools_usage: { Read: 5, Edit: 3 },
-        session_tools_usage: { Read: 2, Edit: 1 },
-        session_duration_seconds: 300,
-      });
-
-      // Reset session stats
-      resetSessionStats();
-
-      const currentStats = get(stats);
-
-      // Total stats should be preserved
-      expect(currentStats.total_input_tokens).toBe(1000);
-      expect(currentStats.total_output_tokens).toBe(2000);
-      expect(currentStats.total_cost_usd).toBe(0.05);
-      expect(currentStats.messages_exchanged).toBe(10);
-      expect(currentStats.code_blocks_generated).toBe(3);
-      expect(currentStats.files_edited).toBe(5);
-      expect(currentStats.files_created).toBe(1);
-      expect(currentStats.tools_usage).toEqual({ Read: 5, Edit: 3 });
-      expect(currentStats.model).toBe("claude-sonnet-4");
-
-      // Session stats should be reset
-      expect(currentStats.session_input_tokens).toBe(0);
-      expect(currentStats.session_output_tokens).toBe(0);
-      expect(currentStats.session_cost_usd).toBe(0);
-      expect(currentStats.session_messages_exchanged).toBe(0);
-      expect(currentStats.session_code_blocks_generated).toBe(0);
-      expect(currentStats.session_files_edited).toBe(0);
-      expect(currentStats.session_files_created).toBe(0);
-      expect(currentStats.session_tools_usage).toEqual({});
-      expect(currentStats.session_duration_seconds).toBe(0);
-    });
-  });
-
-  describe("formattedStats derived store", () => {
-    it("formats token numbers with locale string", () => {
-      stats.update((current) => ({
-        ...current,
-        total_input_tokens: 1234567,
-        total_output_tokens: 7654321,
-        session_input_tokens: 12345,
-        session_output_tokens: 54321,
-      }));
-
-      const formatted = get(formattedStats);
-
-      expect(formatted.totalTokens).toBe("8,888,888");
-      expect(formatted.totalInputTokens).toBe("1,234,567");
-      expect(formatted.totalOutputTokens).toBe("7,654,321");
-      expect(formatted.sessionTokens).toBe("66,666");
-      expect(formatted.sessionInputTokens).toBe("12,345");
-      expect(formatted.sessionOutputTokens).toBe("54,321");
-    });
-
-    it("formats cost with 4 decimal places", () => {
-      stats.update((current) => ({
-        ...current,
-        total_cost_usd: 1.23456,
-        session_cost_usd: 0.00123,
-      }));
-
-      const formatted = get(formattedStats);
-
-      expect(formatted.totalCost).toBe("$1.2346");
-      expect(formatted.sessionCost).toBe("$0.0012");
-    });
-
-    it("formats duration seconds only", () => {
-      stats.update((current) => ({
-        ...current,
-        session_duration_seconds: 45,
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.sessionDuration).toBe("45s");
-    });
-
-    it("formats duration minutes and seconds", () => {
-      stats.update((current) => ({
-        ...current,
-        session_duration_seconds: 125, // 2m 5s
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.sessionDuration).toBe("2m 5s");
-    });
-
-    it("formats duration hours, minutes, and seconds", () => {
-      stats.update((current) => ({
-        ...current,
-        session_duration_seconds: 3725, // 1h 2m 5s
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.sessionDuration).toBe("1h 2m 5s");
-    });
-
-    it("formats duration with zero seconds", () => {
-      stats.update((current) => ({
-        ...current,
-        session_duration_seconds: 3600, // exactly 1h
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.sessionDuration).toBe("1h 0m 0s");
-    });
-
-    it("shows model name when available", () => {
-      stats.update((current) => ({
-        ...current,
-        model: "claude-opus-4-5",
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.model).toBe("claude-opus-4-5");
-    });
-
-    it("shows placeholder when model is null", () => {
-      stats.update((current) => ({
-        ...current,
-        model: null,
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.model).toBe("No model selected");
-    });
-
-    it("formats message counts", () => {
-      stats.update((current) => ({
-        ...current,
-        messages_exchanged: 100,
-        session_messages_exchanged: 10,
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.messagesTotal).toBe("100");
-      expect(formatted.messagesSession).toBe("10");
-    });
-
-    it("formats code block counts", () => {
-      stats.update((current) => ({
-        ...current,
-        code_blocks_generated: 50,
-        session_code_blocks_generated: 5,
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.codeBlocksTotal).toBe("50");
-      expect(formatted.codeBlocksSession).toBe("5");
-    });
-
-    it("formats file counts", () => {
-      stats.update((current) => ({
-        ...current,
-        files_edited: 25,
-        session_files_edited: 3,
-        files_created: 10,
-        session_files_created: 2,
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.filesEditedTotal).toBe("25");
-      expect(formatted.filesEditedSession).toBe("3");
-      expect(formatted.filesCreatedTotal).toBe("10");
-      expect(formatted.filesCreatedSession).toBe("2");
-    });
-
-    it("exposes tools usage directly", () => {
-      const toolsUsage = { Read: 10, Edit: 5, Write: 3 };
-      const sessionToolsUsage = { Read: 2, Edit: 1 };
-
-      stats.update((current) => ({
-        ...current,
-        tools_usage: toolsUsage,
-        session_tools_usage: sessionToolsUsage,
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.toolsUsage).toEqual(toolsUsage);
-      expect(formatted.sessionToolsUsage).toEqual(sessionToolsUsage);
-    });
-
-    it("handles zero values correctly", () => {
-      const formatted = get(formattedStats);
-
-      expect(formatted.totalTokens).toBe("0");
-      expect(formatted.totalCost).toBe("$0.0000");
-      expect(formatted.sessionDuration).toBe("0s");
-      expect(formatted.messagesTotal).toBe("0");
-    });
-
-    it("handles large numbers with proper formatting", () => {
-      stats.update((current) => ({
-        ...current,
-        total_input_tokens: 1000000000, // 1 billion
-        messages_exchanged: 999999,
-      }));
-
-      const formatted = get(formattedStats);
-      expect(formatted.totalInputTokens).toBe("1,000,000,000");
-      expect(formatted.messagesTotal).toBe("999,999");
-    });
-  });
-
-  describe("UsageStats interface", () => {
-    it("supports all expected fields", () => {
-      const fullStats: UsageStats = {
-        total_input_tokens: 100,
-        total_output_tokens: 200,
-        total_cost_usd: 0.01,
-        session_input_tokens: 50,
-        session_output_tokens: 100,
-        session_cost_usd: 0.005,
-        model: "test-model",
-        messages_exchanged: 5,
-        session_messages_exchanged: 2,
-        code_blocks_generated: 3,
-        session_code_blocks_generated: 1,
-        files_edited: 2,
-        session_files_edited: 1,
-        files_created: 1,
-        session_files_created: 0,
-        tools_usage: { Read: 3 },
-        session_tools_usage: { Read: 1 },
-        session_duration_seconds: 60,
-      };
-
-      stats.set(fullStats);
-      const currentStats = get(stats);
-
-      // Verify all fields are present and correct
-      expect(currentStats).toEqual(fullStats);
-    });
-  });
-});

src/lib/tauri.test.ts

@@ -1,388 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { emitMockEvent, setMockInvokeResult } from "../../vitest.setup";
-
-// We need to test the helper functions that are exported
-// The main listener initialization is tested through integration
-
-describe("tauri helpers", () => {
-  describe("getTimeOfDay (inferred from greeting behavior)", () => {
-    it("returns morning for hours 5-11", () => {
-      const date = new Date();
-      date.setHours(8, 0, 0, 0);
-      vi.setSystemTime(date);
-
-      // The getTimeOfDay function is private, but we can verify the greeting prompt includes the time
-      // This tests the logic indirectly
-      expect(date.getHours()).toBeGreaterThanOrEqual(5);
-      expect(date.getHours()).toBeLessThan(12);
-    });
-
-    it("returns afternoon for hours 12-16", () => {
-      const date = new Date();
-      date.setHours(14, 0, 0, 0);
-      vi.setSystemTime(date);
-
-      expect(date.getHours()).toBeGreaterThanOrEqual(12);
-      expect(date.getHours()).toBeLessThan(17);
-    });
-
-    it("returns evening for hours 17-20", () => {
-      const date = new Date();
-      date.setHours(19, 0, 0, 0);
-      vi.setSystemTime(date);
-
-      expect(date.getHours()).toBeGreaterThanOrEqual(17);
-      expect(date.getHours()).toBeLessThan(21);
-    });
-
-    it("returns late night for hours 21-4", () => {
-      const date = new Date();
-      date.setHours(23, 0, 0, 0);
-      vi.setSystemTime(date);
-
-      expect(date.getHours() >= 21 || date.getHours() < 5).toBe(true);
-    });
-  });
-});
-
-describe("tauri event handling", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  describe("connection events", () => {
-    it("emits connected status payload", () => {
-      const payload = {
-        status: "connected",
-        conversation_id: "test-conv-1",
-      };
-
-      // Verify payload structure
-      expect(payload.status).toBe("connected");
-      expect(payload.conversation_id).toBe("test-conv-1");
-    });
-
-    it("emits disconnected status payload", () => {
-      const payload = {
-        status: "disconnected",
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.status).toBe("disconnected");
-    });
-
-    it("emits error status payload", () => {
-      const payload = {
-        status: "error",
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.status).toBe("error");
-    });
-  });
-
-  describe("state change events", () => {
-    it("maps idle state correctly", () => {
-      const payload = {
-        state: "idle",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("idle");
-    });
-
-    it("maps thinking state correctly", () => {
-      const payload = {
-        state: "thinking",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("thinking");
-    });
-
-    it("maps typing state correctly", () => {
-      const payload = {
-        state: "typing",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("typing");
-    });
-
-    it("maps searching state correctly", () => {
-      const payload = {
-        state: "searching",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("searching");
-    });
-
-    it("maps coding state correctly", () => {
-      const payload = {
-        state: "coding",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("coding");
-    });
-
-    it("maps mcp state correctly", () => {
-      const payload = {
-        state: "mcp",
-        tool_name: "some-tool",
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("mcp");
-      expect(payload.tool_name).toBe("some-tool");
-    });
-
-    it("maps permission state correctly", () => {
-      const payload = {
-        state: "permission",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("permission");
-    });
-
-    it("maps success state correctly", () => {
-      const payload = {
-        state: "success",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("success");
-    });
-
-    it("maps error state correctly", () => {
-      const payload = {
-        state: "error",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.state.toLowerCase()).toBe("error");
-    });
-
-    it("defaults unknown state to idle", () => {
-      const stateMap: Record<string, string> = {
-        idle: "idle",
-        thinking: "thinking",
-        typing: "typing",
-        searching: "searching",
-        coding: "coding",
-        mcp: "mcp",
-        permission: "permission",
-        success: "success",
-        error: "error",
-      };
-
-      const unknownState = "unknown-state";
-      const mappedState = stateMap[unknownState.toLowerCase()] || "idle";
-      expect(mappedState).toBe("idle");
-    });
-  });
-
-  describe("output events", () => {
-    it("handles user output type", () => {
-      const payload = {
-        line_type: "user",
-        content: "Hello, world!",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.line_type).toBe("user");
-      expect(payload.content).toBe("Hello, world!");
-    });
-
-    it("handles assistant output type", () => {
-      const payload = {
-        line_type: "assistant",
-        content: "Hi there!",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.line_type).toBe("assistant");
-    });
-
-    it("handles system output type", () => {
-      const payload = {
-        line_type: "system",
-        content: "Connected to Claude Code",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.line_type).toBe("system");
-    });
-
-    it("handles tool output type with tool name", () => {
-      const payload = {
-        line_type: "tool",
-        content: "Tool executed successfully",
-        tool_name: "Read",
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.line_type).toBe("tool");
-      expect(payload.tool_name).toBe("Read");
-    });
-
-    it("handles error output type", () => {
-      const payload = {
-        line_type: "error",
-        content: "An error occurred",
-        tool_name: null,
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.line_type).toBe("error");
-    });
-  });
-
-  describe("session events", () => {
-    it("handles session payload with conversation id", () => {
-      const payload = {
-        session_id: "sess-12345678",
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.session_id).toBe("sess-12345678");
-      expect(payload.conversation_id).toBe("test-conv-1");
-    });
-
-    it("creates truncated session display", () => {
-      const sessionId = "sess-12345678-90ab-cdef";
-      const display = `Session: ${sessionId.substring(0, 8)}...`;
-
-      expect(display).toBe("Session: sess-123...");
-    });
-  });
-
-  describe("working directory events", () => {
-    it("handles cwd payload", () => {
-      const payload = {
-        directory: "/home/user/project",
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.directory).toBe("/home/user/project");
-    });
-  });
-
-  describe("permission events", () => {
-    it("handles permission payload structure", () => {
-      const payload = {
-        id: "perm-123",
-        tool_name: "Bash",
-        tool_input: '{"command": "ls -la"}',
-        description: "Run shell command",
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.id).toBe("perm-123");
-      expect(payload.tool_name).toBe("Bash");
-      expect(payload.tool_input).toContain("command");
-      expect(payload.description).toBe("Run shell command");
-    });
-  });
-
-  describe("question events", () => {
-    it("handles question payload structure", () => {
-      const payload = {
-        id: "q-123",
-        question: "Which option would you like?",
-        options: [
-          { label: "Option A", description: "First option" },
-          { label: "Option B", description: "Second option" },
-        ],
-        conversation_id: "test-conv-1",
-      };
-
-      expect(payload.id).toBe("q-123");
-      expect(payload.question).toBe("Which option would you like?");
-      expect(payload.options).toHaveLength(2);
-    });
-  });
-});
-
-describe("mock event system", () => {
-  it("can emit events through mock system", () => {
-    // The emitMockEvent function should work
-    expect(typeof emitMockEvent).toBe("function");
-  });
-
-  it("can set mock invoke results", () => {
-    setMockInvokeResult("test_command", { result: "success" });
-    // This verifies the mock setup is working
-    expect(typeof setMockInvokeResult).toBe("function");
-  });
-});
-
-describe("greeting system", () => {
-  it("generates greeting prompt with time of day", () => {
-    const timeOfDay = "morning";
-    const prompt = `[System: A new session has started. It's currently ${timeOfDay}. Please greet the user warmly and briefly. Keep it short - just 1-2 sentences.]`;
-
-    expect(prompt).toContain("morning");
-    expect(prompt).toContain("greet the user");
-  });
-
-  it("uses custom greeting prompt when provided", () => {
-    const customPrompt = "Say hello in pirate speak!";
-    const greetingPrompt = customPrompt.trim() || "default greeting";
-
-    expect(greetingPrompt).toBe("Say hello in pirate speak!");
-  });
-
-  it("uses default prompt when custom is empty", () => {
-    const customPrompt = "   ";
-    const defaultPrompt = "default greeting";
-    const greetingPrompt = customPrompt.trim() || defaultPrompt;
-
-    expect(greetingPrompt).toBe(defaultPrompt);
-  });
-});
-
-describe("conversation tracking", () => {
-  it("tracks connected conversations with Set", () => {
-    const connectedConversations = new Set<string>();
-
-    connectedConversations.add("conv-1");
-    expect(connectedConversations.has("conv-1")).toBe(true);
-    expect(connectedConversations.size).toBe(1);
-
-    connectedConversations.add("conv-2");
-    expect(connectedConversations.size).toBe(2);
-
-    connectedConversations.delete("conv-1");
-    expect(connectedConversations.has("conv-1")).toBe(false);
-    expect(connectedConversations.size).toBe(1);
-  });
-});
-
-describe("skip greeting flag", () => {
-  it("flag can be set and reset", () => {
-    let skipNextGreeting = false;
-
-    skipNextGreeting = true;
-    expect(skipNextGreeting).toBe(true);
-
-    // Simulate reset after use
-    if (skipNextGreeting) {
-      skipNextGreeting = false;
-    }
-    expect(skipNextGreeting).toBe(false);
-  });
-});

src/routes/+page.svelte

@@ -24,7 +24,7 @@
   import UpdateNotification from "$lib/components/UpdateNotification.svelte";
 
   let initialized = false;
-  let updateNotification: UpdateNotification | undefined = $state(undefined);
+  let updateNotification: UpdateNotification;
   let achievementPanelOpen = $state(false);
   let currentCharacterState: CharacterState = $state("idle");
   let compactModeActive = $state(false);
@@ -255,7 +255,7 @@
 
       // Apply saved settings on startup
       const config = configStore.getConfig();
-      applyTheme(config.theme, config.custom_theme_colors);
+      applyTheme(config.theme);
       applyFontSize(config.font_size);
 
       // Apply always-on-top setting
@@ -375,9 +375,6 @@
     -webkit-mask:
       linear-gradient(#fff 0 0) content-box,
       linear-gradient(#fff 0 0);
-    mask:
-      linear-gradient(#fff 0 0) content-box,
-      linear-gradient(#fff 0 0);
     -webkit-mask-composite: xor;
     mask-composite: exclude;
     opacity: 0;

vitest.config.ts

@@ -8,23 +8,5 @@ export default defineConfig({
     environment: "jsdom",
     setupFiles: ["./vitest.setup.ts"],
     globals: true,
-    coverage: {
-      provider: "v8",
-      reporter: ["text", "json", "html"],
-      reportsDirectory: "./coverage",
-      include: ["src/lib/**/*.ts"],
-      exclude: [
-        "src/lib/**/*.test.ts",
-        "src/lib/**/*.spec.ts",
-        "src/lib/**/*.d.ts",
-        "src/lib/components/**",
-      ],
-      thresholds: {
-        statements: 15,
-        branches: 13,
-        functions: 13,
-        lines: 15,
-      },
-    },
   },
 });

vitest.setup.ts

@@ -1,288 +1 @@
 import "@testing-library/jest-dom/vitest";
-import { vi, beforeEach } from "vitest";
-
-// Mock Tauri invoke API
-const mockInvokeResults: Record<string, unknown> = {};
-
-export function setMockInvokeResult(command: string, result: unknown) {
-  mockInvokeResults[command] = result;
-}
-
-export function clearMockInvokeResults() {
-  Object.keys(mockInvokeResults).forEach((key) => delete mockInvokeResults[key]);
-}
-
-vi.mock("@tauri-apps/api/core", () => ({
-  invoke: vi.fn((command: string) => {
-    if (command in mockInvokeResults) {
-      const result = mockInvokeResults[command];
-      if (result instanceof Error) {
-        return Promise.reject(result);
-      }
-      return Promise.resolve(result);
-    }
-    // Default return values for common commands
-    switch (command) {
-      case "get_config":
-        return Promise.resolve({
-          model: null,
-          api_key: null,
-          custom_instructions: null,
-          mcp_servers_json: null,
-          auto_granted_tools: [],
-          theme: "dark",
-          greeting_enabled: true,
-          greeting_custom_prompt: null,
-          notifications_enabled: true,
-          notification_volume: 0.7,
-          always_on_top: false,
-          update_checks_enabled: true,
-          character_panel_width: null,
-          font_size: 14,
-          minimize_to_tray: false,
-          streamer_mode: false,
-          streamer_hide_paths: false,
-          compact_mode: false,
-          profile_name: null,
-          profile_avatar_path: null,
-          profile_bio: null,
-          custom_theme_colors: {},
-        });
-      case "list_quick_actions":
-        return Promise.resolve([]);
-      case "list_snippets":
-        return Promise.resolve([]);
-      case "list_sessions":
-        return Promise.resolve([]);
-      case "get_usage_stats":
-        return Promise.resolve({
-          total_messages: 0,
-          total_sessions: 0,
-          total_tokens: 0,
-          total_cost: 0,
-        });
-      case "get_persisted_stats":
-        return Promise.resolve({
-          lifetime_messages: 0,
-          lifetime_sessions: 0,
-          lifetime_tokens: 0,
-          lifetime_cost: 0,
-          achievements: [],
-          unlocked_achievements: [],
-        });
-      case "load_saved_achievements":
-        return Promise.resolve([]);
-      case "list_clipboard_entries":
-        return Promise.resolve([]);
-      case "cleanup_temp_files":
-        return Promise.resolve();
-      case "validate_directory":
-        return Promise.resolve(true);
-      case "git_status":
-        return Promise.resolve({
-          branch: "main",
-          files: [],
-          ahead: 0,
-          behind: 0,
-        });
-      default:
-        return Promise.resolve(null);
-    }
-  }),
-}));
-
-// Mock Tauri event API
-const eventListeners: Map<string, Array<(event: { payload: unknown }) => void>> = new Map();
-
-export function emitMockEvent(eventName: string, payload: unknown) {
-  const listeners = eventListeners.get(eventName) || [];
-  listeners.forEach((listener) => listener({ payload }));
-}
-
-export function clearMockEventListeners() {
-  eventListeners.clear();
-}
-
-vi.mock("@tauri-apps/api/event", () => ({
-  listen: vi.fn((eventName: string, handler: (event: { payload: unknown }) => void) => {
-    const listeners = eventListeners.get(eventName) || [];
-    listeners.push(handler);
-    eventListeners.set(eventName, listeners);
-    // Return an unlisten function
-    return Promise.resolve(() => {
-      const currentListeners = eventListeners.get(eventName) || [];
-      const index = currentListeners.indexOf(handler);
-      if (index > -1) {
-        currentListeners.splice(index, 1);
-      }
-    });
-  }),
-  emit: vi.fn(),
-}));
-
-// Mock Tauri plugins
-vi.mock("@tauri-apps/plugin-dialog", () => ({
-  save: vi.fn(() => Promise.resolve(null)),
-  open: vi.fn(() => Promise.resolve(null)),
-  message: vi.fn(() => Promise.resolve()),
-  ask: vi.fn(() => Promise.resolve(true)),
-  confirm: vi.fn(() => Promise.resolve(true)),
-}));
-
-vi.mock("@tauri-apps/plugin-fs", () => ({
-  writeTextFile: vi.fn(() => Promise.resolve()),
-  readTextFile: vi.fn(() => Promise.resolve("{}")),
-  exists: vi.fn(() => Promise.resolve(false)),
-  mkdir: vi.fn(() => Promise.resolve()),
-  remove: vi.fn(() => Promise.resolve()),
-  readDir: vi.fn(() => Promise.resolve([])),
-}));
-
-vi.mock("@tauri-apps/plugin-opener", () => ({
-  openPath: vi.fn(() => Promise.resolve()),
-  openUrl: vi.fn(() => Promise.resolve()),
-}));
-
-vi.mock("@tauri-apps/plugin-notification", () => ({
-  sendNotification: vi.fn(() => Promise.resolve()),
-  requestPermission: vi.fn(() => Promise.resolve("granted")),
-  isPermissionGranted: vi.fn(() => Promise.resolve(true)),
-}));
-
-vi.mock("@tauri-apps/plugin-clipboard-manager", () => ({
-  writeText: vi.fn(() => Promise.resolve()),
-  readText: vi.fn(() => Promise.resolve("")),
-  writeImage: vi.fn(() => Promise.resolve()),
-  readImage: vi.fn(() => Promise.resolve(null)),
-}));
-
-vi.mock("@tauri-apps/plugin-os", () => ({
-  platform: vi.fn(() => Promise.resolve("linux")),
-  arch: vi.fn(() => Promise.resolve("x86_64")),
-  type: vi.fn(() => Promise.resolve("Linux")),
-  version: vi.fn(() => Promise.resolve("1.0.0")),
-}));
-
-vi.mock("@tauri-apps/plugin-http", () => ({
-  fetch: vi.fn(() =>
-    Promise.resolve({
-      ok: true,
-      status: 200,
-      json: () => Promise.resolve({}),
-      text: () => Promise.resolve(""),
-    })
-  ),
-}));
-
-// Mock browser APIs
-class MockAudioElement {
-  src = "";
-  volume = 1;
-  loop = false;
-  currentTime = 0;
-  paused = true;
-  preload = "auto";
-  onloadeddata: (() => void) | null = null;
-  onended: (() => void) | null = null;
-  onerror: ((e: Event) => void) | null = null;
-
-  play() {
-    this.paused = false;
-    return Promise.resolve();
-  }
-
-  pause() {
-    this.paused = true;
-  }
-
-  load() {
-    if (this.onloadeddata) {
-      setTimeout(() => this.onloadeddata?.(), 0);
-    }
-  }
-
-  addEventListener(event: string, handler: () => void) {
-    if (event === "loadeddata") this.onloadeddata = handler;
-    if (event === "ended") this.onended = handler;
-  }
-
-  removeEventListener() {
-    // No-op for tests
-  }
-}
-
-// @ts-expect-error - Mock Audio constructor
-globalThis.Audio = MockAudioElement;
-
-// Mock localStorage
-const localStorageStore: Record<string, string> = {};
-
-Object.defineProperty(globalThis, "localStorage", {
-  value: {
-    getItem: vi.fn((key: string) => localStorageStore[key] || null),
-    setItem: vi.fn((key: string, value: string) => {
-      localStorageStore[key] = value;
-    }),
-    removeItem: vi.fn((key: string) => {
-      delete localStorageStore[key];
-    }),
-    clear: vi.fn(() => {
-      Object.keys(localStorageStore).forEach((key) => delete localStorageStore[key]);
-    }),
-    key: vi.fn((index: number) => Object.keys(localStorageStore)[index] || null),
-    get length() {
-      return Object.keys(localStorageStore).length;
-    },
-  },
-  writable: true,
-});
-
-// Mock matchMedia
-Object.defineProperty(globalThis, "matchMedia", {
-  writable: true,
-  value: vi.fn((query: string) => ({
-    matches: query.includes("dark"),
-    media: query,
-    onchange: null,
-    addListener: vi.fn(),
-    removeListener: vi.fn(),
-    addEventListener: vi.fn(),
-    removeEventListener: vi.fn(),
-    dispatchEvent: vi.fn(),
-  })),
-});
-
-// Mock ResizeObserver
-class MockResizeObserver {
-  observe = vi.fn();
-  unobserve = vi.fn();
-  disconnect = vi.fn();
-}
-
-globalThis.ResizeObserver = MockResizeObserver as unknown as typeof ResizeObserver;
-
-// Mock IntersectionObserver
-class MockIntersectionObserver {
-  observe = vi.fn();
-  unobserve = vi.fn();
-  disconnect = vi.fn();
-}
-
-globalThis.IntersectionObserver =
-  MockIntersectionObserver as unknown as typeof IntersectionObserver;
-
-// Mock requestAnimationFrame
-globalThis.requestAnimationFrame = vi.fn((callback) => {
-  return setTimeout(callback, 0) as unknown as number;
-});
-
-globalThis.cancelAnimationFrame = vi.fn((id) => {
-  clearTimeout(id);
-});
-
-// Reset all mocks before each test
-beforeEach(() => {
-  vi.clearAllMocks();
-  clearMockInvokeResults();
-  clearMockEventListeners();
-});