deps: update lucide-svelte to 0.564.0

## Summary

Fixes the memory files tab showing as empty on Windows production builds and the "forbidden path" error when trying to read memory files.

## Changes

### 1. List memory files from WSL home directory (commit 1)
- Split `list_memory_files()` into platform-specific implementations
- **Windows**: Use WSL command with `bash -l` to find memory files in WSL home (`~/.claude/projects/.../memory/`)
- **Linux/Mac**: Continue using native filesystem access
- Previously used `dirs::home_dir()` which returns Windows home (`C:\Users\...`), but Claude Code stores files in WSL home

### 2. Use backend command for reading files (commit 2)
- Changed frontend from Tauri's `readTextFile` plugin to `read_file_content` backend command
- Tauri plugin enforces scope restrictions and can't access WSL paths on Windows
- Our backend command already handles WSL paths correctly via `read_file_via_wsl()`
- Matches the pattern used throughout the app for other file operations

## Testing

- ✅ All 426 backend tests pass
- ✅ All frontend tests pass
- ✅ Lint, format, and type checks pass
- ✅ Follows existing WSL file operation patterns in codebase

## Related Issues

Fixes the memory files tab functionality on Windows whilst maintaining full compatibility with Linux/Mac.

✨ This PR was created by Hikari~ 🌸

Reviewed-on: #140
Co-authored-by: Hikari <hikari@nhcarrigan.com>
Co-committed-by: Hikari <hikari@nhcarrigan.com>

CLAUDE.md

@@ -141,6 +141,37 @@ When developing new features, always add corresponding tests:
 
 The goal is to maintain our near-100% coverage as the codebase grows, so future refactoring and changes can be made with confidence!
 
+## Quality Assurance
+
+Before committing any changes, **always run the full test suite**:
+
+```bash
+./check-all.sh
+```
+
+This script runs all checks in the correct order:
+
+1. Frontend linting (ESLint)
+2. Frontend formatting (Prettier)
+3. Frontend type checking (svelte-check)
+4. Frontend tests with coverage (Vitest)
+5. Backend linting (Clippy with strict rules)
+6. Backend tests with coverage (cargo test + llvm-cov)
+
+**Important**: The script requires Node.js and Rust toolchains to be available:
+
+- **Node.js tools** (pnpm, npm): Source nvm first if needed: `source ~/.nvm/nvm.sh`
+- **Rust tools** (cargo, clippy): Should be in PATH via `~/.cargo/bin/`
+
+If `check-all.sh` reports any failures:
+
+1. Read the error messages carefully - they usually explain what needs fixing
+2. Fix the issues (linting errors, test failures, etc.)
+3. Run `check-all.sh` again to verify the fixes
+4. Only commit once all checks pass ✨
+
+**Never commit code that doesn't pass `check-all.sh`** - this ensures code quality and prevents broken builds!
+
 ## Project Context
 
 Hikari Desktop is a Tauri-based desktop application that wraps Claude Code with a visual anime character (Hikari) who appears on screen. This is a personal project where Hikari can sign her work and act as herself!

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hikari-desktop",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "",
   "type": "module",
   "scripts": {
@@ -64,7 +64,7 @@
     "@tauri-apps/plugin-store": "^2",
     "codemirror": "^6.0.2",
     "highlight.js": "^11.11.1",
-    "lucide-svelte": "^0.563.0",
+    "lucide-svelte": "0.564.0",
     "marked": "^17.0.1"
   },
   "devDependencies": {

pnpm-lock.yaml

@@ -120,8 +120,8 @@ importers:
         specifier: ^11.11.1
         version: 11.11.1
       lucide-svelte:
-        specifier: ^0.563.0
-        version: 0.563.0(svelte@5.46.3)
+        specifier: 0.564.0
+        version: 0.564.0(svelte@5.46.3)
       marked:
         specifier: ^17.0.1
         version: 17.0.1
@@ -1671,8 +1671,8 @@ packages:
     resolution: {integrity: sha512-B5Y16Jr9LB9dHVkh6ZevG+vAbOsNOYCX+sXvFWFu7B3Iz5mijW3zdbMyhsh8ANd2mSWBYdJgnqi+mL7/LrOPYg==}
     engines: {node: 20 || >=22}
 
-  lucide-svelte@0.563.0:
-    resolution: {integrity: sha512-pjZKw7TpQcamfQrx7YdbOHgmrcNeKiGGMD0tKZQaVktwSsbqw28CsKc2Q97ttwjytiCWkJyOa8ij2Q+Og0nPfQ==}
+  lucide-svelte@0.564.0:
+    resolution: {integrity: sha512-jeubFecyzbeze/Zwu5pFHHrv/u8OtiZ7VesXXus4cAnfRQlmb8TDtiC5gb485z8e4aAqe8FF7I0OVB/TDFAggg==}
     peerDependencies:
       svelte: ^3 || ^4 || ^5.0.0-next.42
 
@@ -3658,7 +3658,7 @@ snapshots:
 
   lru-cache@11.2.4: {}
 
-  lucide-svelte@0.563.0(svelte@5.46.3):
+  lucide-svelte@0.564.0(svelte@5.46.3):
     dependencies:
       svelte: 5.46.3
 

src-tauri/Cargo.lock

@@ -1636,7 +1636,7 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
 name = "hikari-desktop"
-version = "1.4.0"
+version = "1.5.1"
 dependencies = [
  "chrono",
  "dirs 5.0.1",

src-tauri/Cargo.toml

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

src-tauri/src/commands.rs

@@ -49,6 +49,59 @@ fn wsl_path_to_windows(wsl_path: &str) -> Option<String> {
     }
 }
 
+/// Create a Command instance for executing Claude CLI commands
+/// On Windows, this will use WSL to execute the command
+/// On other platforms, it executes directly
+fn create_claude_command() -> std::process::Command {
+    #[cfg(target_os = "windows")]
+    {
+        // Use `which` inside WSL to find the claude binary dynamically
+        // Non-login shells launched by `wsl` don't inherit the full user PATH,
+        // so we need to use a login shell to get the correct PATH
+        let which_output = std::process::Command::new("wsl")
+            .args(["-e", "bash", "-l", "-c", "which claude"])
+            .output();
+
+        match which_output {
+            Ok(output) if output.status.success() => {
+                let claude_path = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                let mut cmd = std::process::Command::new("wsl");
+                cmd.arg(claude_path);
+                cmd
+            }
+            _ => {
+                // Fallback to just "claude" if which fails
+                // This maintains backwards compatibility
+                let mut cmd = std::process::Command::new("wsl");
+                cmd.arg("claude");
+                cmd
+            }
+        }
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        // Use `which` to find the claude binary dynamically
+        // This works regardless of how Claude Code was installed (standalone, npm, etc.)
+        // and avoids hardcoding paths
+        let which_output = std::process::Command::new("which")
+            .arg("claude")
+            .output();
+
+        match which_output {
+            Ok(output) if output.status.success() => {
+                let claude_path = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                std::process::Command::new(claude_path)
+            }
+            _ => {
+                // Fallback to just "claude" if which fails
+                // This maintains backwards compatibility
+                std::process::Command::new("claude")
+            }
+        }
+    }
+}
+
 #[tauri::command]
 pub async fn start_claude(
     bridge_manager: State<'_, SharedBridgeManager>,
@@ -1166,6 +1219,55 @@ pub struct MemoryFilesResponse {
 
 #[tauri::command]
 pub async fn list_memory_files() -> Result<MemoryFilesResponse, String> {
+    // On Windows, we need to look in the WSL home directory
+    // On Linux/Mac, use the native home directory
+    #[cfg(target_os = "windows")]
+    {
+        list_memory_files_via_wsl().await
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        list_memory_files_native().await
+    }
+}
+
+/// List memory files via WSL (for Windows)
+#[cfg(target_os = "windows")]
+async fn list_memory_files_via_wsl() -> Result<MemoryFilesResponse, String> {
+    use std::process::Command;
+
+    // Use WSL to find all memory files in the WSL home directory
+    // This script finds all "memory" directories and lists their files
+    let script = r#"
+        find ~/.claude/projects -type d -name memory 2>/dev/null | while read dir; do
+            find "$dir" -maxdepth 1 -type f 2>/dev/null
+        done | sort
+    "#;
+
+    let output = Command::new("wsl")
+        .args(["-e", "bash", "-l", "-c", script])
+        .output()
+        .map_err(|e| format!("Failed to execute WSL command: {}", e))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(format!("Failed to list memory files: {}", stderr));
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let files: Vec<String> = stdout
+        .lines()
+        .filter(|line| !line.trim().is_empty())
+        .map(|line| line.trim().to_string())
+        .collect();
+
+    Ok(MemoryFilesResponse { files })
+}
+
+/// List memory files using native filesystem (for Linux/Mac)
+#[cfg(not(target_os = "windows"))]
+async fn list_memory_files_native() -> Result<MemoryFilesResponse, String> {
     use std::fs;
 
     // Get the .claude directory in the user's home
@@ -1233,7 +1335,7 @@ pub async fn list_memory_files() -> Result<MemoryFilesResponse, String> {
 pub async fn get_claude_version() -> Result<String, String> {
     tracing::debug!("Getting Claude CLI version");
 
-    let output = std::process::Command::new("claude")
+    let output = create_claude_command()
         .arg("--version")
         .output();
 
@@ -1323,7 +1425,7 @@ fn parse_plugin_list(stdout: &str) -> Vec<PluginInfo> {
 pub async fn list_plugins() -> Result<Vec<PluginInfo>, String> {
     tracing::debug!("Listing Claude Code plugins");
 
-    let output = std::process::Command::new("claude")
+    let output = create_claude_command()
         .arg("plugin")
         .arg("list")
         .output();
@@ -1352,7 +1454,7 @@ pub async fn list_plugins() -> Result<Vec<PluginInfo>, String> {
 pub async fn install_plugin(plugin_name: String) -> Result<String, String> {
     tracing::debug!("Installing plugin: {}", plugin_name);
 
-    let output = std::process::Command::new("claude")
+    let output = create_claude_command()
         .arg("plugin")
         .arg("install")
         .arg(&plugin_name)
@@ -1381,7 +1483,7 @@ pub async fn install_plugin(plugin_name: String) -> Result<String, String> {
 pub async fn uninstall_plugin(plugin_name: String) -> Result<String, String> {
     tracing::debug!("Uninstalling plugin: {}", plugin_name);
 
-    let output = std::process::Command::new("claude")
+    let output = create_claude_command()
         .arg("plugin")
         .arg("uninstall")
         .arg(&plugin_name)
@@ -1410,7 +1512,7 @@ pub async fn uninstall_plugin(plugin_name: String) -> Result<String, String> {
 pub async fn enable_plugin(plugin_name: String) -> Result<String, String> {
     tracing::debug!("Enabling plugin: {}", plugin_name);
 
-    let output = std::process::Command::new("claude")
+    let output = create_claude_command()
         .arg("plugin")
         .arg("enable")
         .arg(&plugin_name)
@@ -1439,7 +1541,7 @@ pub async fn enable_plugin(plugin_name: String) -> Result<String, String> {
 pub async fn disable_plugin(plugin_name: String) -> Result<String, String> {
     tracing::debug!("Disabling plugin: {}", plugin_name);
 
-    let output = std::process::Command::new("claude")
+    let output = create_claude_command()
         .arg("plugin")
         .arg("disable")
         .arg(&plugin_name)
@@ -1468,7 +1570,7 @@ pub async fn disable_plugin(plugin_name: String) -> Result<String, String> {
 pub async fn update_plugin(plugin_name: String) -> Result<String, String> {
     tracing::debug!("Updating plugin: {}", plugin_name);
 
-    let output = std::process::Command::new("claude")
+    let output = create_claude_command()
         .arg("plugin")
         .arg("update")
         .arg(&plugin_name)
@@ -1540,7 +1642,7 @@ fn parse_marketplace_list(stdout: &str) -> Vec<MarketplaceInfo> {
 pub async fn list_marketplaces() -> Result<Vec<MarketplaceInfo>, String> {
     tracing::debug!("Listing plugin marketplaces");
 
-    let output = std::process::Command::new("claude")
+    let output = create_claude_command()
         .arg("plugin")
         .arg("marketplace")
         .arg("list")
@@ -1573,7 +1675,7 @@ pub async fn list_marketplaces() -> Result<Vec<MarketplaceInfo>, String> {
 pub async fn add_marketplace(source: String) -> Result<String, String> {
     tracing::debug!("Adding marketplace: {}", source);
 
-    let output = std::process::Command::new("claude")
+    let output = create_claude_command()
         .arg("plugin")
         .arg("marketplace")
         .arg("add")
@@ -1606,7 +1708,7 @@ pub async fn add_marketplace(source: String) -> Result<String, String> {
 pub async fn remove_marketplace(name: String) -> Result<String, String> {
     tracing::debug!("Removing marketplace: {}", name);
 
-    let output = std::process::Command::new("claude")
+    let output = create_claude_command()
         .arg("plugin")
         .arg("marketplace")
         .arg("remove")
@@ -1746,7 +1848,7 @@ fn parse_mcp_server_list(stdout: &str) -> Vec<McpServerInfo> {
 pub async fn list_mcp_servers() -> Result<Vec<McpServerInfo>, String> {
     tracing::debug!("Listing MCP servers");
 
-    let output = std::process::Command::new("claude")
+    let output = create_claude_command()
         .arg("mcp")
         .arg("list")
         .output();
@@ -1788,7 +1890,7 @@ pub async fn get_mcp_server(name: String) -> Result<McpServerInfo, String> {
 pub async fn remove_mcp_server(name: String) -> Result<String, String> {
     tracing::debug!("Removing MCP server: {}", name);
 
-    let output = std::process::Command::new("claude")
+    let output = create_claude_command()
         .arg("mcp")
         .arg("remove")
         .arg(&name)
@@ -1823,7 +1925,7 @@ pub async fn add_mcp_server(
 ) -> Result<String, String> {
     tracing::debug!("Adding MCP server: {} with transport {}", name, transport);
 
-    let mut cmd = std::process::Command::new("claude");
+    let mut cmd = create_claude_command();
     cmd.arg("mcp").arg("add");
 
     // Add transport flag
@@ -1871,7 +1973,7 @@ pub async fn add_mcp_server(
 pub async fn get_mcp_server_details(name: String) -> Result<String, String> {
     tracing::debug!("Getting detailed info for MCP server: {}", name);
 
-    let output = std::process::Command::new("claude")
+    let output = create_claude_command()
         .arg("mcp")
         .arg("get")
         .arg(&name)
@@ -1908,6 +2010,49 @@ mod tests {
         tokio::runtime::Runtime::new().unwrap().block_on(f)
     }
 
+    // ==================== create_claude_command tests ====================
+
+    #[test]
+    #[cfg(target_os = "windows")]
+    fn test_create_claude_command_windows() {
+        // On Windows, should create a command that uses wsl with full path to claude
+        // The path is resolved dynamically via `which` in a login shell
+        let cmd = create_claude_command();
+        let program = cmd.get_program();
+
+        assert_eq!(program, "wsl");
+
+        // Verify the first argument is a path to claude (full path from `which`)
+        // or fallback to just "claude" if which fails
+        let args: Vec<&std::ffi::OsStr> = cmd.get_args().collect();
+        assert_eq!(args.len(), 1);
+
+        let arg_str = args[0].to_string_lossy();
+        assert!(
+            arg_str.contains("claude"),
+            "Expected argument to contain 'claude', got: {}",
+            arg_str
+        );
+    }
+
+    #[test]
+    #[cfg(not(target_os = "windows"))]
+    fn test_create_claude_command_linux() {
+        // On Linux/Mac, should create a command that uses the full path to claude
+        // (resolved via `which` command)
+        let cmd = create_claude_command();
+        let program = cmd.get_program();
+
+        // The program should be the full path to claude (from `which`)
+        // or fallback to "claude" if which fails
+        let program_str = program.to_string_lossy();
+        assert!(
+            program_str.ends_with("claude"),
+            "Expected program to end with 'claude', got: {}",
+            program_str
+        );
+    }
+
     // ==================== validate_directory tests ====================
 
     #[test]

src-tauri/src/wsl_bridge.rs

@@ -129,6 +129,11 @@ impl WslBridge {
             return Err("Process already running".to_string());
         }
 
+        // Check if Claude binary is installed before attempting to start
+        if Command::new("which").arg("claude").output().ok().is_none_or(|output| !output.status.success()) {
+            return Err("Claude Code is not installed. Please install it using:\n\ncurl -fsSL https://claude.ai/install.sh | bash".to_string());
+        }
+
         // Load saved achievements and stats when starting a new session
         let app_clone = app.clone();
         let stats = self.stats.clone();
@@ -1868,6 +1873,22 @@ mod tests {
         assert!(!bridge.is_running());
     }
 
+    #[test]
+    fn test_claude_binary_check_command_structure() {
+        // Test that we're using the correct command to check for Claude binary
+        let output = Command::new("which").arg("claude").output();
+
+        // The command should execute successfully (even if claude is not found)
+        // We're just verifying the command structure is valid
+        assert!(output.is_ok(), "which command should execute without error");
+
+        // Verify the check logic returns a boolean
+        // This is the same logic used in start() to check if claude is installed
+        let _result = output.ok().is_none_or(|o| !o.status.success());
+        // If claude is not installed, _result will be true (show error)
+        // If claude is installed, _result will be false (proceed with connection)
+    }
+
     #[test]
     fn test_create_shared_bridge_manager() {
         use crate::bridge_manager::create_shared_bridge_manager;

src-tauri/tauri.conf.json

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

src/lib/components/MemoryBrowserPanel.svelte

@@ -1,7 +1,6 @@
 <script lang="ts">
   import { onMount } from "svelte";
   import { invoke } from "@tauri-apps/api/core";
-  import { readTextFile } from "@tauri-apps/plugin-fs";
   import Markdown from "./Markdown.svelte";
 
   let memoryFiles: string[] = $state([]);
@@ -33,7 +32,8 @@
     isLoading = true;
     error = null;
     try {
-      const content = await readTextFile(filePath);
+      // Use our backend command instead of Tauri plugin to handle WSL paths
+      const content = await invoke<string>("read_file_content", { path: filePath });
       fileContent = content;
       selectedFile = filePath;
     } catch (e) {