v0.2.0

clean architecture refactor, performance, resilience, DX/UX

architecture:
- 13 crates with proper domain/application/infrastructure layers
- domain crate: newtypes, ports (Plugin, AppLauncher), constants
- kernel: pure orchestrator
- shared UI state machine (k-launcher-ui-core)
- merged plugin-api into domain as ports module
- granular file structure (no monolithic lib.rs)
- all tests extracted to tests/ directories

features:
- frecency boost in search results
- empty query shows top frecent apps
- append-only frecency log with configurable compaction
- config-driven styling (all colors, sizes, debounce)
- configurable terminal emulator, external plugin timeout
- log rotation with max_log_files
- loading indicator, descriptive placeholder text
- graceful shutdown via iced::exit() + Plugin::shutdown()
- --version flag, panic hook, signal handling (SIGINT/SIGTERM)
- SpawnInTerminal in external plugin protocol

performance:
- ~1500 -> ~50 heap allocs per keystroke
- reused Matcher, Pattern, char buffer across entries
- Arc<str> for shared result fields
- pre-filter before fuzzy matching
- partial sort for top frecent IDs
- cached lowercase names in entries

resilience:
- parking_lot (no mutex poisoning)
- thiserror hierarchy (PluginError, ConfigError, AppError)
- all silent error swallowing replaced with tracing::warn
- config parse errors logged

quality:
- named constants (no magic strings/numbers)
- named types (no anonymous tuples)
- Rgba newtype with validation
- domain newtype validation (debug_assert non-empty)
- man page, LICENSE (MIT), PKGBUILD, example config
- plugin development guide updated
- make check (fmt + clippy + test), make dev (RUST_LOG=debug)

style: format code for better readability in tests and function signatures

fix: update build_entries function signature to ignore frecency parameter

fix(review): bugs, arch violations, design smells

P1 bugs:
- unix_launcher: shell_split respects quoted args (was split_whitespace)
- plugin-host: 5s timeout on external plugin search
- ui: handle engine init panic, wire error state
- ui-egui: read window config instead of always using defaults
- plugin-url: use OpenPath action instead of SpawnProcess+xdg-open

Architecture:
- remove WindowConfig (mirror of WindowCfg); use WindowCfg directly
- remove on_select closure from SearchResult (domain leakage)
- remove LaunchAction::Custom; add Plugin::on_selected + SearchEngine::on_selected
- apps: record frecency via on_selected instead of embedded closure

Design smells:
- frecency: extract decay_factor helper, write outside mutex
- apps: remove cfg(test) cache_path hack; add new_for_test ctor
- apps: stable ResultId using name+exec to prevent collision
- files: stable ResultId using full path instead of index
- plugin-host: remove k-launcher-os-bridge dep (WindowConfig gone)

Update iced dependency in Cargo.toml to disable default features and add additional ones

feat(app): enhance engine initialization with EngineHandle and update run function signature

feat: production hardening (panic isolation, file logging, apps cache)

- Kernel::search wraps each plugin in catch_unwind; panics are logged and return []
- init_logging() adds daily rolling file at ~/.local/share/k-launcher/logs/
- AppsPlugin caches entries to ~/.cache/k-launcher/apps.bin via bincode; stale-while-revalidate on subsequent launches
- 57 tests pass

refactor: remove client module and associated show command logic

fix(app): format code for clarity in update function

chore: update .gitignore and enhance README with compositor setup instructions

chore(docs): remove unused screenshot file

feature/prod-ready (#1)

Reviewed-on: #1

fix(calc): remove ambiguous log alias, use ln/log2/log10 explicitly

fix(calc): fix log/ln naming, cache math context, strengthen sin(pi) test

feat(calc): add math functions (sqrt, sin, cos, etc.) and pi/e constants

refactor(calc): rename preprocess, extend underscore test assertions

feat(calc): strip underscore digit separators

feat: update dependencies for improved compatibility and performance

feat: add plugin-url for URL handling and open in browser functionality

feat: add support for external plugins and enhance plugin management

feat: add Makefile for build, run, and installation commands

feat: add required features for k-launcher-egui and update dependencies

feat: update README and add documentation for installation, configuration, usage, and plugin development

feat: enhance configuration management and UI styling, remove unused theme module

feat: add k-launcher-config crate for configuration management and integrate with existing components

feat: add k-launcher-ui-egui crate for enhanced UI

- Introduced a new crate `k-launcher-ui-egui` to provide a graphical user interface using eframe and egui.
- Updated the workspace configuration in `Cargo.toml` to include the new crate.
- Implemented the main application logic in `src/app.rs`, handling search functionality and user interactions.
- Created a library entry point in `src/lib.rs` to expose the `run` function for launching the UI.
- Modified the `k-launcher` crate to include a new binary target for the egui-based launcher.
- Added a new main file `src/main_egui.rs` to initialize and run the egui UI with the existing kernel and launcher components.

feat: implement OS bridge and enhance app launcher functionality

feat: add FilesPlugin for file searching and integrate into KLauncher

feat: implement frecency tracking for app usage and enhance search functionality

feat: add CmdPlugin for executing terminal commands and update workspace configuration

refactor: update dependencies and improve keyboard event handling in KLauncherApp

refactor: simplify theme usage and enhance AppsPlugin structure

feat: restructure k-launcher workspace and add core functionality

- Updated Cargo.toml to include a new k-launcher crate and reorganized workspace members.
- Introduced a README.md file detailing the project philosophy, architecture, and technical specifications.
- Implemented a new Kernel struct in k-launcher-kernel for managing plugins and search functionality.
- Created a Plugin trait for plugins to implement, allowing for asynchronous search operations.
- Developed k-launcher-ui with an Iced-based UI for user interaction, including search input and result display.
- Added AppsPlugin and CalcPlugin to handle application launching and basic calculations, respectively.
- Established a theme module for UI styling, focusing on an Aero aesthetic.
- Removed unnecessary main.rs files from plugin crates, streamlining the project structure.

Initialize k-launcher project structure with multiple crates and basic configurations

crates/plugins/plugin-calc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "plugin-calc"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 
 [lib]
@@ -10,5 +10,9 @@ path = "src/lib.rs"
 [dependencies]
 async-trait = { workspace = true }
 evalexpr = "13"
-k-launcher-kernel = { path = "../../k-launcher-kernel" }
+k-launcher-domain = { workspace = true }
+tokio = { workspace = true }
+
+[dev-dependencies]
+k-launcher-domain = { workspace = true }
 tokio = { workspace = true }

crates/plugins/plugin-calc/src/eval.rs

@@ -0,0 +1,45 @@
+use std::sync::LazyLock;
+
+pub(crate) const MATH_FNS: &[&str] = &[
+    "sqrt", "sin", "cos", "tan", "asin", "acos", "atan", "ln", "log2", "log10", "exp", "abs",
+    "ceil", "floor", "round",
+];
+
+pub(crate) fn strip_numeric_separators(expr: &str) -> String {
+    expr.replace('_', "")
+}
+
+pub(crate) fn should_eval(query: &str) -> bool {
+    let q = query.strip_prefix('=').unwrap_or(query);
+    q.chars()
+        .next()
+        .map(|c| c.is_ascii_digit() || c == '(' || c == '-')
+        .unwrap_or(false)
+        || query.starts_with('=')
+        || MATH_FNS.iter().any(|f| q.starts_with(f))
+}
+
+pub(crate) static MATH_CTX: LazyLock<evalexpr::HashMapContext<evalexpr::DefaultNumericTypes>> =
+    LazyLock::new(|| {
+        use evalexpr::*;
+        context_map! {
+            "pi" => float std::f64::consts::PI,
+            "e"  => float std::f64::consts::E,
+            "sqrt"  => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.sqrt()))),
+            "sin"   => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.sin()))),
+            "cos"   => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.cos()))),
+            "tan"   => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.tan()))),
+            "asin"  => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.asin()))),
+            "acos"  => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.acos()))),
+            "atan"  => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.atan()))),
+            "ln"    => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.ln()))),
+            "log2"  => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.log2()))),
+            "log10" => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.log10()))),
+            "exp"   => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.exp()))),
+            "abs"   => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.abs()))),
+            "ceil"  => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.ceil()))),
+            "floor" => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.floor()))),
+            "round" => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.round())))
+        }
+        .expect("static math context must be valid")
+    });

crates/plugins/plugin-calc/src/lib.rs

@@ -1,154 +1,4 @@
-use async_trait::async_trait;
-use evalexpr::eval_number_with_context;
-use k_launcher_kernel::{LaunchAction, Plugin, ResultId, ResultTitle, Score, SearchResult};
-use std::sync::LazyLock;
+mod eval;
+mod plugin;
 
-pub struct CalcPlugin;
-
-impl CalcPlugin {
-    pub fn new() -> Self {
-        Self
-    }
-}
-
-impl Default for CalcPlugin {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-fn strip_numeric_separators(expr: &str) -> String {
-    expr.replace('_', "")
-}
-
-const MATH_FNS: &[&str] = &[
-    "sqrt", "sin", "cos", "tan", "asin", "acos", "atan", "ln", "log2", "log10", "exp", "abs",
-    "ceil", "floor", "round",
-];
-
-fn should_eval(query: &str) -> bool {
-    let q = query.strip_prefix('=').unwrap_or(query);
-    q.chars()
-        .next()
-        .map(|c| c.is_ascii_digit() || c == '(' || c == '-')
-        .unwrap_or(false)
-        || query.starts_with('=')
-        || MATH_FNS.iter().any(|f| q.starts_with(f))
-}
-
-static MATH_CTX: LazyLock<evalexpr::HashMapContext<evalexpr::DefaultNumericTypes>> = LazyLock::new(
-    || {
-        use evalexpr::*;
-        context_map! {
-            "pi" => float std::f64::consts::PI,
-            "e"  => float std::f64::consts::E,
-            "sqrt"  => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.sqrt()))),
-            "sin"   => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.sin()))),
-            "cos"   => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.cos()))),
-            "tan"   => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.tan()))),
-            "asin"  => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.asin()))),
-            "acos"  => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.acos()))),
-            "atan"  => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.atan()))),
-            "ln"    => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.ln()))),
-            "log2"  => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.log2()))),
-            "log10" => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.log10()))),
-            "exp"   => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.exp()))),
-            "abs"   => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.abs()))),
-            "ceil"  => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.ceil()))),
-            "floor" => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.floor()))),
-            "round" => Function::new(|a: &Value<DefaultNumericTypes>| Ok(Value::from_float(a.as_number()?.round())))
-        }
-        .expect("static math context must be valid")
-    },
-);
-
-#[async_trait]
-impl Plugin for CalcPlugin {
-    fn name(&self) -> &str {
-        "calc"
-    }
-
-    async fn search(&self, query: &str) -> Vec<SearchResult> {
-        if !should_eval(query) {
-            return vec![];
-        }
-        let raw = query.strip_prefix('=').unwrap_or(query);
-        let expr_owned = strip_numeric_separators(raw);
-        let expr = expr_owned.as_str();
-        match eval_number_with_context(expr, &*MATH_CTX) {
-            Ok(n) if n.is_finite() => {
-                let value_str = if n.fract() == 0.0 {
-                    format!("{}", n as i64)
-                } else {
-                    format!("{n}")
-                };
-                let display = format!("= {value_str}");
-                vec![SearchResult {
-                    id: ResultId::new("calc-result"),
-                    title: ResultTitle::new(display),
-                    description: Some(format!("{expr_owned} · Enter to copy")),
-                    icon: None,
-                    score: Score::new(90),
-                    action: LaunchAction::CopyToClipboard(value_str),
-                }]
-            }
-            _ => vec![],
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[tokio::test]
-    async fn calc_valid_expr() {
-        let p = CalcPlugin::new();
-        let results = p.search("2+2").await;
-        assert_eq!(results[0].title.as_str(), "= 4");
-    }
-
-    #[tokio::test]
-    async fn calc_non_numeric_returns_empty() {
-        let p = CalcPlugin::new();
-        assert!(p.search("firefox").await.is_empty());
-    }
-
-    #[tokio::test]
-    async fn calc_bad_expr_returns_empty() {
-        let p = CalcPlugin::new();
-        assert!(p.search("1/0").await.is_empty());
-    }
-
-    #[tokio::test]
-    async fn calc_sqrt() {
-        let p = CalcPlugin::new();
-        let results = p.search("sqrt(9)").await;
-        assert_eq!(results[0].title.as_str(), "= 3");
-    }
-
-    #[tokio::test]
-    async fn calc_sin_pi() {
-        let p = CalcPlugin::new();
-        let results = p.search("sin(pi)").await;
-        assert!(!results.is_empty());
-        let title = results[0].title.as_str();
-        let val: f64 = title.trim_start_matches("= ").parse().unwrap();
-        assert!(val.abs() < 1e-10, "sin(pi) should be near zero, got {val}");
-    }
-
-    #[tokio::test]
-    async fn calc_underscore_separator() {
-        let p = CalcPlugin::new();
-        let results = p.search("1_000 * 2").await;
-        assert_eq!(results[0].title.as_str(), "= 2000");
-        assert_eq!(
-            results[0].description.as_deref(),
-            Some("1000 * 2 · Enter to copy")
-        );
-        assert!(matches!(
-            &results[0].action,
-            LaunchAction::CopyToClipboard(v) if v == "2000"
-        ));
-    }
-}
+pub use plugin::*;

crates/plugins/plugin-calc/src/plugin.rs

@@ -0,0 +1,59 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use evalexpr::eval_number_with_context;
+use k_launcher_domain::{LaunchAction, Plugin, ResultId, ResultTitle, Score, SearchResult};
+
+use crate::eval::{MATH_CTX, should_eval, strip_numeric_separators};
+
+const RESULT_ID: &str = "calc-result";
+const RESULT_SCORE: u32 = 90;
+
+pub struct CalcPlugin;
+
+impl CalcPlugin {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl Default for CalcPlugin {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl Plugin for CalcPlugin {
+    fn name(&self) -> &str {
+        "calc"
+    }
+
+    async fn search(&self, query: &str) -> Vec<SearchResult> {
+        if !should_eval(query) {
+            return vec![];
+        }
+        let raw = query.strip_prefix('=').unwrap_or(query);
+        let expr_owned = strip_numeric_separators(raw);
+        let expr = expr_owned.as_str();
+        match eval_number_with_context(expr, &*MATH_CTX) {
+            Ok(n) if n.is_finite() => {
+                let value_str = if n.fract() == 0.0 {
+                    format!("{}", n as i64)
+                } else {
+                    format!("{n}")
+                };
+                let display = format!("= {value_str}");
+                vec![SearchResult {
+                    id: ResultId::new(RESULT_ID),
+                    title: ResultTitle::new(display),
+                    description: Some(Arc::from(format!("{expr_owned} · Enter to copy"))),
+                    icon: None,
+                    score: Score::new(RESULT_SCORE),
+                    action: LaunchAction::CopyToClipboard(value_str),
+                }]
+            }
+            _ => vec![],
+        }
+    }
+}

crates/plugins/plugin-calc/tests/calc.rs

@@ -0,0 +1,53 @@
+use k_launcher_domain::{LaunchAction, Plugin};
+use plugin_calc::CalcPlugin;
+
+#[tokio::test]
+async fn calc_valid_expr() {
+    let p = CalcPlugin::new();
+    let results = p.search("2+2").await;
+    assert_eq!(results[0].title.as_str(), "= 4");
+}
+
+#[tokio::test]
+async fn calc_non_numeric_returns_empty() {
+    let p = CalcPlugin::new();
+    assert!(p.search("firefox").await.is_empty());
+}
+
+#[tokio::test]
+async fn calc_bad_expr_returns_empty() {
+    let p = CalcPlugin::new();
+    assert!(p.search("1/0").await.is_empty());
+}
+
+#[tokio::test]
+async fn calc_sqrt() {
+    let p = CalcPlugin::new();
+    let results = p.search("sqrt(9)").await;
+    assert_eq!(results[0].title.as_str(), "= 3");
+}
+
+#[tokio::test]
+async fn calc_sin_pi() {
+    let p = CalcPlugin::new();
+    let results = p.search("sin(pi)").await;
+    assert!(!results.is_empty());
+    let title = results[0].title.as_str();
+    let val: f64 = title.trim_start_matches("= ").parse().unwrap();
+    assert!(val.abs() < 1e-10, "sin(pi) should be near zero, got {val}");
+}
+
+#[tokio::test]
+async fn calc_underscore_separator() {
+    let p = CalcPlugin::new();
+    let results = p.search("1_000 * 2").await;
+    assert_eq!(results[0].title.as_str(), "= 2000");
+    assert_eq!(
+        results[0].description.as_deref(),
+        Some("1000 * 2 · Enter to copy")
+    );
+    assert!(matches!(
+        &results[0].action,
+        LaunchAction::CopyToClipboard(v) if v == "2000"
+    ));
+}