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-apps/tests/frecency.rs

@@ -0,0 +1,21 @@
+use plugin_apps::frecency::FrecencyStore;
+
+#[test]
+fn record_increments_count() {
+    let store = FrecencyStore::new_for_test();
+    store.record("app-firefox");
+    store.record("app-firefox");
+    assert!(store.frecency_score("app-firefox") > 0);
+}
+
+#[test]
+fn top_ids_returns_sorted_order() {
+    let store = FrecencyStore::new_for_test();
+    store.record("app-firefox");
+    store.record("app-code");
+    store.record("app-code");
+    store.record("app-code");
+    let top = store.top_ids(2);
+    assert_eq!(top[0], "app-code");
+    assert_eq!(top[1], "app-firefox");
+}

crates/plugins/plugin-apps/tests/linux.rs

@@ -0,0 +1,27 @@
+#[cfg(target_os = "linux")]
+mod linux_tests {
+    use plugin_apps::linux::clean_exec;
+
+    #[test]
+    fn strips_bare_field_code() {
+        assert_eq!(clean_exec("app --file %f"), "app --file");
+    }
+
+    #[test]
+    fn strips_multiple_field_codes() {
+        assert_eq!(clean_exec("app %U --flag"), "app --flag");
+    }
+
+    #[test]
+    fn preserves_quoted_value() {
+        assert_eq!(
+            clean_exec(r#"app --arg="value" %U"#),
+            r#"app --arg="value""#
+        );
+    }
+
+    #[test]
+    fn handles_plain_exec() {
+        assert_eq!(clean_exec("firefox"), "firefox");
+    }
+}

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

@@ -0,0 +1,260 @@
+use std::sync::Arc;
+
+use k_launcher_domain::Plugin;
+use plugin_apps::frecency::FrecencyStore;
+use plugin_apps::{
+    AppName, AppsPlugin, DesktopEntry, DesktopEntrySource, ExecCommand, build_entries,
+    humanize_category, load_from_path, new_matcher, parse_pattern, save_to_path, score_match,
+};
+
+fn ephemeral_frecency() -> Arc<FrecencyStore> {
+    FrecencyStore::new_for_test()
+}
+
+struct MockEntry {
+    name: String,
+    exec: String,
+    category: Option<String>,
+    keywords: Vec<String>,
+}
+
+struct MockSource {
+    entries: Vec<MockEntry>,
+}
+
+impl MockSource {
+    fn with(entries: Vec<(&str, &str)>) -> Self {
+        Self {
+            entries: entries
+                .into_iter()
+                .map(|(n, e)| MockEntry {
+                    name: n.to_string(),
+                    exec: e.to_string(),
+                    category: None,
+                    keywords: vec![],
+                })
+                .collect(),
+        }
+    }
+
+    fn with_categories(entries: Vec<(&str, &str, &str)>) -> Self {
+        Self {
+            entries: entries
+                .into_iter()
+                .map(|(n, e, c)| MockEntry {
+                    name: n.to_string(),
+                    exec: e.to_string(),
+                    category: Some(c.to_string()),
+                    keywords: vec![],
+                })
+                .collect(),
+        }
+    }
+
+    fn with_keywords(entries: Vec<(&str, &str, Vec<&str>)>) -> Self {
+        Self {
+            entries: entries
+                .into_iter()
+                .map(|(n, e, kw)| MockEntry {
+                    name: n.to_string(),
+                    exec: e.to_string(),
+                    category: None,
+                    keywords: kw.into_iter().map(|s| s.to_string()).collect(),
+                })
+                .collect(),
+        }
+    }
+}
+
+impl DesktopEntrySource for MockSource {
+    fn entries(&self) -> Vec<DesktopEntry> {
+        self.entries
+            .iter()
+            .map(|e| DesktopEntry {
+                name: AppName::new(e.name.clone()),
+                exec: ExecCommand::new(e.exec.clone()),
+                icon: None,
+                category: e.category.clone(),
+                keywords: e.keywords.clone(),
+            })
+            .collect()
+    }
+}
+
+#[tokio::test]
+async fn apps_prefix_match() {
+    let p = AppsPlugin::new_for_test(
+        MockSource::with(vec![("Firefox", "firefox")]),
+        ephemeral_frecency(),
+    );
+    let results = p.search("fire").await;
+    assert_eq!(results[0].title.as_str(), "Firefox");
+}
+
+#[tokio::test]
+async fn apps_no_match_returns_empty() {
+    let p = AppsPlugin::new_for_test(
+        MockSource::with(vec![("Firefox", "firefox")]),
+        ephemeral_frecency(),
+    );
+    assert!(p.search("zz").await.is_empty());
+}
+
+#[tokio::test]
+async fn apps_empty_query_no_frecency_returns_empty() {
+    let p = AppsPlugin::new_for_test(
+        MockSource::with(vec![("Firefox", "firefox")]),
+        ephemeral_frecency(),
+    );
+    assert!(p.search("").await.is_empty());
+}
+
+#[test]
+fn score_match_abbreviation() {
+    let mut matcher = new_matcher();
+    let pattern = parse_pattern("vsc");
+    let mut buf = Vec::new();
+    assert!(
+        score_match(
+            &mut matcher,
+            &pattern,
+            "visual studio code",
+            &mut buf,
+            "visual studio code",
+            "vsc"
+        )
+        .is_some()
+    );
+}
+
+#[test]
+fn score_match_exact_beats_prefix() {
+    let mut matcher = new_matcher();
+    let mut buf = Vec::new();
+    let exact_pattern = parse_pattern("firefox");
+    let fire_pattern = parse_pattern("fire");
+    let gf_pattern = parse_pattern("gf");
+
+    let exact = score_match(
+        &mut matcher,
+        &exact_pattern,
+        "firefox",
+        &mut buf,
+        "firefox",
+        "firefox",
+    );
+    let prefix = score_match(
+        &mut matcher,
+        &fire_pattern,
+        "firefox",
+        &mut buf,
+        "firefox",
+        "fire",
+    );
+    let abbrev = score_match(
+        &mut matcher,
+        &gf_pattern,
+        "gnu firefox",
+        &mut buf,
+        "gnu firefox",
+        "gf",
+    );
+    let substr = score_match(
+        &mut matcher,
+        &fire_pattern,
+        "ice firefox",
+        &mut buf,
+        "ice firefox",
+        "fire",
+    );
+    assert!(exact.is_some());
+    assert!(prefix.is_some());
+    assert!(abbrev.is_some());
+    assert!(substr.is_some());
+    assert!(exact.unwrap() > prefix.unwrap());
+}
+
+#[tokio::test]
+async fn apps_abbreviation_match() {
+    let p = AppsPlugin::new_for_test(
+        MockSource::with(vec![("Visual Studio Code", "code")]),
+        ephemeral_frecency(),
+    );
+    let results = p.search("vsc").await;
+    assert_eq!(results.len(), 1);
+    assert_eq!(results[0].title.as_str(), "Visual Studio Code");
+    assert!(results[0].score.value() > 0);
+}
+
+#[tokio::test]
+async fn apps_keyword_match() {
+    let p = AppsPlugin::new_for_test(
+        MockSource::with_keywords(vec![("Code", "code", vec!["editor", "ide"])]),
+        ephemeral_frecency(),
+    );
+    let results = p.search("editor").await;
+    assert_eq!(results.len(), 1);
+    assert_eq!(results[0].score.value(), 50);
+}
+
+#[tokio::test]
+async fn apps_fuzzy_typo_match() {
+    let p = AppsPlugin::new_for_test(
+        MockSource::with(vec![("Firefox", "firefox")]),
+        ephemeral_frecency(),
+    );
+    let results = p.search("frefox").await;
+    assert!(
+        !results.is_empty(),
+        "nucleo should fuzzy-match 'frefox' to 'Firefox'"
+    );
+    assert!(results[0].score.value() > 0);
+}
+
+#[test]
+fn humanize_category_splits_camel_case() {
+    assert_eq!(humanize_category("TextEditor"), "Text Editor");
+    assert_eq!(humanize_category("WebBrowser"), "Web Browser");
+    assert_eq!(humanize_category("Development"), "Development");
+}
+
+#[tokio::test]
+async fn apps_category_appears_in_description() {
+    let p = AppsPlugin::new_for_test(
+        MockSource::with_categories(vec![("Code", "code", "Text Editor")]),
+        ephemeral_frecency(),
+    );
+    let results = p.search("code").await;
+    assert_eq!(results[0].description.as_deref(), Some("Text Editor"));
+}
+
+#[tokio::test]
+async fn apps_empty_query_returns_top_frecent() {
+    let frecency = ephemeral_frecency();
+    frecency.record("app-Code:code");
+    frecency.record("app-Code:code");
+    frecency.record("app-Firefox:firefox");
+    let p = AppsPlugin::new_for_test(
+        MockSource::with(vec![("Firefox", "firefox"), ("Code", "code")]),
+        frecency,
+    );
+    let results = p.search("").await;
+    assert_eq!(results.len(), 2);
+    assert_eq!(results[0].title.as_str(), "Code");
+}
+
+#[test]
+fn apps_loads_from_cache_when_source_is_empty() {
+    let frecency = ephemeral_frecency();
+    let cache_file =
+        std::env::temp_dir().join(format!("k-launcher-test-{}.bin", std::process::id()));
+
+    let source = MockSource::with(vec![("Firefox", "firefox")]);
+    let entries = build_entries(&source, &frecency);
+    save_to_path(&cache_file, &entries);
+
+    let loaded = load_from_path(&cache_file).unwrap();
+    assert!(loaded.contains_key("app-Firefox:firefox"));
+
+    std::fs::remove_file(&cache_file).ok();
+}