more tidying

Cargo.toml

···
 [workspace.dependencies]
 # workspace crates
 gpuikit = { path = "crates/gpuikit", version = "0.1.0" }
-gpuikit-assets = { path = "crates/gpuikit-assets", version = "0.1.0" }
 gpuikit-theme = { path = "crates/gpuikit-theme", version = "0.1.0" }
 gpuikit-utils = { path = "crates/gpuikit-utils", version = "0.1.0" }
 gpuikit-keymap = { path = "crates/gpuikit-keymap", version = "0.1.0" }

crates/gpuikit-assets/Cargo.toml

···
-[package]
-name = "gpuikit-assets"
-version.workspace = true
-edition.workspace = true
-authors.workspace = true
-license.workspace = true
-repository.workspace = true
-homepage.workspace = true
-description = "Asset management for GPUI applications"
-readme = "README.md"
-keywords = ["gpui", "assets", "embed", "resources", "icons"]
-categories = ["gui", "multimedia"]
-
-[lib]
-name = "gpuikit_assets"
-path = "src/lib.rs"
-
-[dependencies]
-# GPUI framework
-gpui = { workspace = true }
-
-# Embedding assets in binary
-rust-embed = { workspace = true }
-
-# Error handling
-anyhow = { workspace = true }
-
-[dev-dependencies]
-gpui = { workspace = true, features = ["test-support"] }

crates/gpuikit-assets/src/lib.rs

···
-//! Asset management for GPUI applications
-//!
-//! This crate provides utilities for embedding and managing assets in GPUI applications.
-
-use anyhow::{anyhow, Result};
-use gpui::{AssetSource, SharedString};
-use rust_embed::RustEmbed;
-use std::borrow::Cow;
-
-/// Trait for types that can serve as embedded asset sources
-pub trait EmbeddedAssets: RustEmbed {
-    /// Get an asset by path
-    fn get_asset(path: &str) -> Option<Cow<'static, [u8]>> {
-        Self::get(path).map(|file| file.data)
-    }
-
-    /// Check if an asset exists
-    fn has_asset(path: &str) -> bool {
-        Self::get(path).is_some()
-    }
-
-    /// List all assets matching a pattern
-    fn list_assets(pattern: Option<&str>) -> Vec<String> {
-        let iter = Self::iter();
-        match pattern {
-            Some(pat) => iter
-                .filter(|path| path.contains(pat))
-                .map(|s| s.to_string())
-                .collect(),
-            None => iter.map(|s| s.to_string()).collect(),
-        }
-    }
-}
-
-/// Default implementation for all RustEmbed types
-impl<T: RustEmbed> EmbeddedAssets for T {}
-
-/// Asset manager for loading and caching embedded assets
-#[derive(Debug, Clone)]
-pub struct AssetManager {}
-
-impl AssetManager {
-    /// Create a new asset manager
-    pub fn new() -> Self {
-        Self {}
-    }
-
-    /// Load an embedded asset
-    pub fn load_embedded<T: EmbeddedAssets>(&self, path: &str) -> Result<Vec<u8>> {
-        T::get_asset(path)
-            .map(|data| data.to_vec())
-            .ok_or_else(|| anyhow!("Asset not found: {}", path))
-    }
-
-    /// Load an embedded text asset
-    pub fn load_text<T: EmbeddedAssets>(&self, path: &str) -> Result<String> {
-        let data = self.load_embedded::<T>(path)?;
-        String::from_utf8(data).map_err(|e| anyhow!("Invalid UTF-8 in asset {}: {}", path, e))
-    }
-
-    /// List all embedded assets
-    pub fn list_embedded<T: EmbeddedAssets>(&self, pattern: Option<&str>) -> Vec<String> {
-        T::list_assets(pattern)
-    }
-}
-
-/// GPUI AssetSource implementation for embedded assets
-pub struct EmbeddedAssetSource<T: EmbeddedAssets + Send + Sync> {
-    _phantom: std::marker::PhantomData<T>,
-}
-
-impl<T: EmbeddedAssets + Send + Sync> Default for EmbeddedAssetSource<T> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<T: EmbeddedAssets + Send + Sync> EmbeddedAssetSource<T> {
-    /// Create a new embedded asset source
-    pub fn new() -> Self {
-        Self {
-            _phantom: std::marker::PhantomData,
-        }
-    }
-}
-
-impl<T: EmbeddedAssets + Send + Sync + 'static> AssetSource for EmbeddedAssetSource<T> {
-    fn load(&self, path: &str) -> Result<Option<Cow<'static, [u8]>>> {
-        Ok(T::get_asset(path))
-    }
-
-    fn list(&self, prefix: &str) -> Result<Vec<SharedString>> {
-        Ok(T::list_assets(Some(prefix))
-            .into_iter()
-            .map(|s| s.into())
-            .collect())
-    }
-}
-
-/// Helper macro to define an embedded assets module
-#[macro_export]
-macro_rules! embed_assets {
-    ($name:ident, $folder:expr) => {
-        #[derive(::rust_embed::RustEmbed)]
-        #[folder = $folder]
-        pub struct $name;
-
-        impl $name {
-            /// Create a GPUI asset source for these embedded assets
-            pub fn asset_source() -> $crate::EmbeddedAssetSource<Self> {
-                $crate::EmbeddedAssetSource::new()
-            }
-        }
-    };
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_asset_manager() {
-        let _manager = AssetManager::new();
-        // Just verify that we can create an asset manager
-    }
-}

crates/gpuikit-keymap/Cargo.toml

···
 license.workspace = true
 repository.workspace = true
 homepage.workspace = true
-description = "Flexible keymap and keyboard shortcut management for GPUI applications"
-readme = "README.md"
-keywords = ["gpui", "keymap", "keyboard", "shortcuts", "keybindings"]
-categories = ["gui", "config"]
 
 [lib]
 name = "gpuikit_keymap"
 path = "src/lib.rs"
 
 [dependencies]
-# GPUI framework
+anyhow = { workspace = true }
 gpui = { workspace = true }
-
-# Serialization
+log = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-
-# Error handling
-anyhow = { workspace = true }
-
-# Logging
-log = { workspace = true }
 
 [dev-dependencies]
 gpui = { workspace = true, features = ["test-support"] }
···
 
 [features]
 default = []
-# Enable schema generation for keymap files
 schema = ["schemars"]
 
-# Optional dependencies
 [dependencies.schemars]
 version = "0.8"
 optional = true
 
-# Package metadata for crates.io
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
-
-[[example]]
-name = "basic_keymap"
-path = "examples/basic_keymap.rs"
-
-[[example]]
-name = "custom_actions"
-path = "examples/custom_actions.rs"
-
-[[example]]
-name = "load_from_json"
-path = "examples/load_from_json.rs"

crates/gpuikit-keymap/README.md

···
-# Keymap Module Documentation
-
-The `keymap` module provides JSON-based keyboard shortcut configuration for GPUI applications, allowing keybindings to be loaded from external files rather than hardcoded in the application.
-
-## Features
-
-- **JSON Configuration**: Define keybindings in human-readable JSON files
-- **Multiple Contexts**: Support for context-specific keybindings (e.g., Editor, Menu, Global)
-- **Action Parameters**: Pass parameters to actions through keybindings
-- **Platform-specific**: Automatically loads platform-appropriate default keymaps
-- **Flexible Loading**: Load from files, strings, or create programmatically
-- **Type-safe**: Compile-time checking when converting to GPUI bindings
-
-## Quick Start
-
-### Basic Usage
-
-```rust
-use gpui_editor::keymap::KeymapCollection;
-
-// Create a keymap collection
-let mut keymaps = KeymapCollection::new();
-
-// Load default keymaps for the current platform
-keymaps.load_defaults()?;
-
-// Or load from a custom file
-keymaps.load_file("my-keymaps.json")?;
-
-// Get binding specifications
-let specs = keymaps.get_binding_specs()?;
-
-// Convert to GPUI bindings (requires mapping action names to concrete types)
-for spec in specs {
-    match spec.action_name.as_str() {
-        "editor::Save" => {
-            cx.bind_keys([KeyBinding::new(&spec.keystrokes, SaveAction, spec.context.as_deref())]);
-        }
-        // ... handle other actions
-    }
-}
-```
-
-## JSON Format
-
-### Simple Bindings
-
-```json
-{
-  "context": "Editor",
-  "use_key_equivalents": true,
-  "bindings": {
-    "cmd-s": "editor::Save",
-    "cmd-z": "editor::Undo",
-    "cmd-shift-z": "editor::Redo"
-  }
-}
-```
-
-### Complex Bindings with Parameters
-
-```json
-{
-  "bindings": [
-    {
-      "key": "cmd-z",
-      "action": ["editor::Undo", { "count": 1 }]
-    },
-    {
-      "key": "cmd-k cmd-c",
-      "action": "editor::CommentLine",
-      "context": "CodeEditor"
-    }
-  ]
-}
-```
-
-### Multiple Contexts
-
-```json
-[
-  {
-    "context": "Global",
-    "bindings": {
-      "cmd-q": "application::Quit",
-      "cmd-n": "application::NewWindow"
-    }
-  },
-  {
-    "context": "Editor",
-    "bindings": {
-      "cmd-s": "editor::Save",
-      "cmd-z": "editor::Undo"
-    }
-  }
-]
-```
-
-## Keymap Structure
-
-### Fields
-
-- **`context`** (optional): String specifying where these bindings apply
-- **`use_key_equivalents`**: Boolean for platform-specific key mappings
-- **`bindings`**: Either a map of keystrokes to actions (simple) or an array of binding entries (complex)
-
-### Keystroke Format
-
-Keystrokes follow the pattern: `[modifiers-]key`
-
-**Modifiers:**
-- `cmd` / `ctrl`: Command (macOS) or Control (Windows/Linux)
-- `alt` / `option`: Alt/Option key
-- `shift`: Shift key
-- `fn`: Function key
-
-**Examples:**
-- `cmd-s`: Command+S (macOS) or Ctrl+S (Windows/Linux)
-- `cmd-shift-z`: Command+Shift+Z
-- `alt-left`: Alt+Left Arrow
-- `cmd-k cmd-c`: Command+K followed by Command+C (chord)
-
-## Action Registry
-
-To convert keymap specifications to actual GPUI actions, you need an action registry:
-
-```rust
-use gpui_editor::keymap::{SimpleActionRegistry, ActionRegistry};
-
-let mut registry = SimpleActionRegistry::new();
-
-// Register simple actions
-registry.register_simple("editor::Save", SaveAction);
-registry.register_simple("editor::Open", OpenAction);
-
-// Register actions with parameter handling
-registry.register("editor::Undo", |params| {
-    if let Some(params) = params {
-        // Handle parameters
-        let count = params["count"].as_u64().unwrap_or(1);
-        Box::new(UndoAction::with_count(count))
-    } else {
-        Box::new(UndoAction::default())
-    }
-});
-
-// Use the registry to convert keymaps to actions
-let actions = keymaps.to_actions(&registry)?;
-```
-
-## Integration with GPUI
-
-Since GPUI's `KeyBinding::new` requires concrete action types, you need to map action names from the keymap to actual action types:
-
-```rust
-// Define your actions
-actions!(editor, [Save, Open, Undo, Redo]);
-
-// Load keymaps
-let mut keymaps = KeymapCollection::new();
-keymaps.load_defaults()?;
-
-// Get binding specifications
-let specs = keymaps.get_binding_specs()?;
-
-// Create GPUI bindings
-let mut bindings = Vec::new();
-for spec in specs {
-    let context = spec.context.as_deref();
-    
-    match spec.action_name.as_str() {
-        "editor::Save" => {
-            bindings.push(KeyBinding::new(&spec.keystrokes, Save, context));
-        }
-        "editor::Open" => {
-            bindings.push(KeyBinding::new(&spec.keystrokes, Open, context));
-        }
-        "editor::Undo" => {
-            bindings.push(KeyBinding::new(&spec.keystrokes, Undo, context));
-        }
-        "editor::Redo" => {
-            bindings.push(KeyBinding::new(&spec.keystrokes, Redo, context));
-        }
-        _ => {
-            log::warn!("Unknown action: {}", spec.action_name);
-        }
-    }
-}
-
-// Register with GPUI
-cx.bind_keys(bindings);
-```
-
-## Default Keymaps
-
-The module includes built-in default keymaps for different platforms:
-
-- **macOS**: Uses `cmd` modifier
-- **Windows/Linux**: Uses `ctrl` modifier
-
-Load defaults with:
-
-```rust
-keymaps.load_defaults()?;
-```
-
-## Programmatic Creation
-
-You can also create keymaps programmatically:
-
-```rust
-use gpui_editor::keymap::{Keymap, KeyBindings, ActionValue};
-use std::collections::HashMap;
-
-let mut bindings = HashMap::new();
-bindings.insert(
-    "cmd-s".to_string(),
-    ActionValue::Simple("editor::Save".to_string())
-);
-bindings.insert(
-    "cmd-z".to_string(),
-    ActionValue::WithParams(vec![
-        json!("editor::Undo"),
-        json!({ "count": 1 })
-    ])
-);
-
-let keymap = Keymap {
-    context: Some("Editor".to_string()),
-    use_key_equivalents: true,
-    bindings: KeyBindings::Simple(bindings),
-};
-```
-
-## Helper Functions
-
-The module provides several helper functions:
-
-```rust
-use gpui_editor::keymap::{binding, binding_with_context};
-
-// Create a simple binding
-let b = binding("cmd-s", "editor::Save");
-
-// Create a binding with context
-let b = binding_with_context("enter", "menu::Select", "Menu");
-```
-
-## Error Handling
-
-All loading operations return `Result<T, anyhow::Error>`:
-
-```rust
-match keymaps.load_file("custom-keymap.json") {
-    Ok(_) => println!("Loaded successfully"),
-    Err(e) => {
-        eprintln!("Failed to load keymap: {}", e);
-        // Fall back to defaults
-        keymaps.load_defaults()?;
-    }
-}
-```
-
-## Examples
-
-### Loading from Multiple Sources
-
-```rust
-let mut keymaps = KeymapCollection::new();
-
-// Load base keymaps
-keymaps.load_defaults()?;
-
-// Load user customizations (if they exist)
-if Path::new("~/.config/myapp/keymap.json").exists() {
-    keymaps.load_file("~/.config/myapp/keymap.json")?;
-}
-
-// Load project-specific keymaps
-if Path::new(".myapp/keymap.json").exists() {
-    keymaps.load_file(".myapp/keymap.json")?;
-}
-```
-
-### Custom Action Registry
-
-```rust
-struct MyActionRegistry {
-    actions: HashMap<String, Box<dyn Fn() -> Box<dyn Action>>>,
-}
-
-impl ActionRegistry for MyActionRegistry {
-    fn get_action(&self, name: &str, params: Option<Value>) -> Option<Box<dyn Action>> {
-        self.actions.get(name).map(|factory| factory())
-    }
-}
-```
-
-## API Reference
-
-### `KeymapCollection`
-
-- `new()` - Create a new empty collection
-- `load_file(path)` - Load keymaps from a JSON file
-- `load_json(json)` - Load keymaps from a JSON string
-- `load_defaults()` - Load platform-specific defaults
-- `get_binding_specs()` - Get binding specifications
-- `to_actions(registry)` - Convert to boxed actions using a registry
-- `keymaps()` - Get all keymaps in the collection
-- `clear()` - Remove all keymaps
-
-### `Keymap`
-
-- `context: Option<String>` - Optional context for bindings
-- `use_key_equivalents: bool` - Use platform-specific keys
-- `bindings: KeyBindings` - The actual key bindings
-
-### `KeyBindings`
-
-- `Simple(HashMap<String, ActionValue>)` - Simple keystroke->action map
-- `Complex(Vec<KeyBindingEntry>)` - List of binding entries
-
-### `ActionValue`
-
-- `Simple(String)` - Simple action name
-- `WithParams(Vec<Value>)` - Action with parameters
-
-### `BindingSpec`
-
-- `keystrokes: String` - The key combination
-- `action_name: String` - Name of the action
-- `action_params: Option<Value>` - Optional parameters
-- `context: Option<String>` - Optional context
-
-## Best Practices
-
-1. **Use Contexts**: Separate keybindings by context to avoid conflicts
-2. **Platform Compatibility**: Test keymaps on all target platforms
-3. **Document Actions**: Keep a list of all available actions and their parameters
-4. **Provide Defaults**: Always have fallback keybindings if loading fails
-5. **User Customization**: Allow users to override default keymaps
-6. **Validate Early**: Check keymap validity during loading, not at runtime
-
-## Migration from Hardcoded Bindings
-
-Before (hardcoded):
-```rust
-cx.bind_keys([
-    KeyBinding::new("cmd-s", Save, None),
-    KeyBinding::new("cmd-o", Open, None),
-    // ... many more
-]);
-```
-
-After (with keymap module):
-```rust
-let mut keymaps = KeymapCollection::new();
-keymaps.load_defaults()?;
-
-for spec in keymaps.get_binding_specs()? {
-    // Map spec to concrete action and register
-}
-```
-
-## Troubleshooting
-
-### Common Issues
-
-1. **"Unknown action" warnings**: Ensure all actions in the keymap are registered
-2. **Platform differences**: Use `cmd` for macOS and `ctrl` for Windows/Linux
-3. **Context not working**: Verify the context name matches exactly
-4. **Parameters not passing**: Check JSON structure for action parameters
-
-### Debug Output
-
-Enable logging to see keymap loading details:
-```rust
-env::set_var("RUST_LOG", "debug");
-env_logger::init();
-```

crates/gpuikit-keymap/default-keymap.json

···
 [
   {
-    "context": "Editor",
-    "use_key_equivalents": true,
-    "bindings": {
-      "up": "editor_demo::MoveUp",
-      "down": "editor_demo::MoveDown",
-      "left": "editor_demo::MoveLeft",
-      "right": "editor_demo::MoveRight",
-      "shift-up": "editor_demo::MoveUpWithShift",
-      "shift-down": "editor_demo::MoveDownWithShift",
-      "shift-left": "editor_demo::MoveLeftWithShift",
-      "shift-right": "editor_demo::MoveRightWithShift",
-      "backspace": "editor_demo::Backspace",
-      "delete": "editor_demo::Delete",
-      "enter": "editor_demo::InsertNewline",
-      "cmd-a": "editor_demo::SelectAll",
-      "ctrl-a": "editor_demo::SelectAll",
-      "escape": "editor_demo::Escape",
-      "cmd-c": "editor_demo::Copy",
-      "ctrl-c": "editor_demo::Copy",
-      "cmd-x": "editor_demo::Cut",
-      "ctrl-x": "editor_demo::Cut",
-      "cmd-v": "editor_demo::Paste",
-      "ctrl-v": "editor_demo::Paste",
-      "cmd-z": "editor::Undo",
-      "ctrl-z": "editor::Undo",
-      "cmd-shift-z": "editor::Redo",
-      "ctrl-shift-z": "editor::Redo",
-      "cmd-]": "editor_demo::NextTheme",
-      "ctrl-]": "editor_demo::NextTheme",
-      "cmd-[": "editor_demo::PreviousTheme",
-      "ctrl-[": "editor_demo::PreviousTheme",
-      "cmd-shift-]": "editor_demo::NextLanguage",
-      "ctrl-shift-]": "editor_demo::NextLanguage",
-      "cmd-shift-[": "editor_demo::PreviousLanguage",
-      "ctrl-shift-[": "editor_demo::PreviousLanguage",
-      "home": "editor::MoveToBeginningOfLine",
-      "end": "editor::MoveToEndOfLine",
-      "cmd-home": "editor::MoveToBeginning",
-      "ctrl-home": "editor::MoveToBeginning",
-      "cmd-end": "editor::MoveToEnd",
-      "ctrl-end": "editor::MoveToEnd",
-      "pageup": "editor::PageUp",
-      "pagedown": "editor::PageDown",
-      "cmd-up": "editor::MoveToBeginning",
-      "ctrl-up": "editor::MoveToBeginning",
-      "cmd-down": "editor::MoveToEnd",
-      "ctrl-down": "editor::MoveToEnd",
-      "cmd-left": "editor::MoveToBeginningOfLine",
-      "ctrl-left": "editor::MoveToBeginningOfLine",
-      "cmd-right": "editor::MoveToEndOfLine",
-      "ctrl-right": "editor::MoveToEndOfLine",
-      "alt-left": "editor::MoveToPreviousWordStart",
-      "alt-right": "editor::MoveToNextWordEnd",
-      "alt-shift-left": "editor::SelectToPreviousWordStart",
-      "alt-shift-right": "editor::SelectToNextWordEnd",
-      "shift-home": "editor::SelectToBeginningOfLine",
-      "shift-end": "editor::SelectToEndOfLine",
-      "cmd-shift-home": "editor::SelectToBeginning",
-      "ctrl-shift-home": "editor::SelectToBeginning",
-      "cmd-shift-end": "editor::SelectToEnd",
-      "ctrl-shift-end": "editor::SelectToEnd",
-      "shift-pageup": "editor::SelectPageUp",
-      "shift-pagedown": "editor::SelectPageDown",
-      "tab": "editor::Tab",
-      "shift-tab": "editor::Backtab",
-      "cmd-shift-d": "editor::DuplicateLine",
-      "ctrl-shift-d": "editor::DuplicateLine",
-      "alt-up": "editor::MoveLineUp",
-      "alt-down": "editor::MoveLineDown",
-      "cmd-/": "editor::ToggleComment",
-      "ctrl-/": "editor::ToggleComment",
-      "cmd-d": "editor::SelectNextOccurrence",
-      "ctrl-d": "editor::SelectNextOccurrence",
-      "cmd-f": "editor::Find",
-      "ctrl-f": "editor::Find",
-      "cmd-shift-f": "editor::FindInFiles",
-      "ctrl-shift-f": "editor::FindInFiles",
-      "f3": "editor::FindNext",
-      "shift-f3": "editor::FindPrevious",
-      "cmd-g": "editor::FindNext",
-      "ctrl-g": "editor::FindNext",
-      "cmd-shift-g": "editor::FindPrevious",
-      "ctrl-shift-g": "editor::FindPrevious",
-      "cmd-h": "editor::Replace",
-      "ctrl-h": "editor::Replace",
-      "cmd-shift-h": "editor::ReplaceAll",
-      "ctrl-shift-h": "editor::ReplaceAll"
-    }
-  },
-  {
-    "context": "Menu",
-    "use_key_equivalents": true,
+    "context": "Global",
     "bindings": {
-      "up": "menu::SelectPrevious",
-      "down": "menu::SelectNext",
-      "enter": "menu::Confirm",
-      "escape": "menu::Cancel",
-      "home": "menu::SelectFirst",
-      "end": "menu::SelectLast",
-      "pageup": "menu::SelectFirst",
-      "pagedown": "menu::SelectLast"
+      "cmd-q": "app::Quit",
+      "ctrl-q": "app::Quit",
+      "cmd-w": "window::Close",
+      "ctrl-w": "window::Close"
     }
   },
   {
-    "context": "Global",
-    "use_key_equivalents": true,
+    "context": "Core",
     "bindings": {
-      "cmd-q": "application::Quit",
-      "ctrl-q": "application::Quit",
-      "cmd-w": "workspace::CloseWindow",
-      "ctrl-w": "workspace::CloseWindow",
-      "cmd-n": "workspace::NewFile",
-      "ctrl-n": "workspace::NewFile",
-      "cmd-o": "workspace::OpenFile",
-      "ctrl-o": "workspace::OpenFile",
-      "cmd-s": "workspace::Save",
-      "ctrl-s": "workspace::Save",
-      "cmd-shift-s": "workspace::SaveAs",
-      "ctrl-shift-s": "workspace::SaveAs",
-      "cmd-shift-n": "workspace::NewWindow",
-      "ctrl-shift-n": "workspace::NewWindow",
-      "f11": "application::ToggleFullScreen",
-      "cmd-=": "application::ZoomIn",
-      "ctrl-=": "application::ZoomIn",
-      "cmd-+": "application::ZoomIn",
-      "ctrl-+": "application::ZoomIn",
-      "cmd--": "application::ZoomOut",
-      "ctrl--": "application::ZoomOut",
-      "cmd-0": "application::ResetZoom",
-      "ctrl-0": "application::ResetZoom"
+      "up": "core::Previous",
+      "down": "core::Next",
+      "tab": "core:Next",
+      "enter": "core::Confirm",
+      "escape": "core::Cancel",
+      "home": "core::First",
+      "end": "core::Last",
+      "pageup": "core::First",
+      "pagedown": "core::Last"
     }
   }
 ]

crates/gpuikit-keymap/src/lib.rs

···
 //! keybindings to be loaded from external files rather than hardcoded.
 
 use anyhow::{anyhow, Context as _, Result};
-use gpui::Action;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fs;
···
     #[serde(skip_serializing_if = "Option::is_none")]
     pub context: Option<String>,
 
-    /// Whether to use platform-specific key equivalents
-    #[serde(default)]
-    pub use_key_equivalents: bool,
-
     /// The key bindings in this keymap
-    pub bindings: KeyBindings,
-}
-
-/// Represents the bindings section of a keymap
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum KeyBindings {
-    /// Simple map of keystroke -> action
-    Simple(HashMap<String, ActionValue>),
-    /// List of individual key binding entries (for more complex configurations)
-    Complex(Vec<KeyBindingEntry>),
-}
-
-/// Represents a single key binding entry
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct KeyBindingEntry {
-    /// The keystroke sequence (e.g., "cmd-s", "ctrl-shift-p")
-    pub key: String,
-
-    /// The action to trigger
-    pub action: ActionValue,
-
-    /// Optional context where this binding applies
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub context: Option<String>,
-}
-
-/// Represents an action value in the keymap
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum ActionValue {
-    /// Simple action name
-    Simple(String),
-    /// Action with parameters
-    WithParams(Vec<serde_json::Value>),
+    pub bindings: HashMap<String, String>,
 }
 
-impl ActionValue {
-    /// Get the action name from this value
-    pub fn action_name(&self) -> Result<String> {
-        match self {
-            ActionValue::Simple(name) => Ok(name.clone()),
-            ActionValue::WithParams(values) => {
-                if let Some(first) = values.first() {
-                    if let Some(name) = first.as_str() {
-                        return Ok(name.to_string());
-                    }
-                }
-                Err(anyhow!(
-                    "Invalid action format: expected action name as first element"
-                ))
-            }
+impl Keymap {
+    /// Create a new keymap with the given bindings
+    pub fn new(bindings: HashMap<String, String>) -> Self {
+        Self {
+            context: None,
+            bindings,
         }
     }
 
-    /// Get the action parameters if any
-    pub fn params(&self) -> Option<serde_json::Value> {
-        match self {
-            ActionValue::Simple(_) => None,
-            ActionValue::WithParams(values) => {
-                if values.len() > 1 {
-                    Some(values[1].clone())
-                } else {
-                    None
-                }
-            }
+    /// Create a new keymap with context
+    pub fn with_context(context: impl Into<String>, bindings: HashMap<String, String>) -> Self {
+        Self {
+            context: Some(context.into()),
+            bindings,
         }
     }
 }
···
         Err(anyhow!("Invalid keymap JSON format"))
     }
 
-    /// Load default keymaps for the current platform
+    /// Load default keymaps
     pub fn load_defaults(&mut self) -> Result<()> {
-        let default_keymap = default_keymap_json();
+        let default_keymap = include_str!("../default-keymap.json");
         self.load_json(default_keymap)?;
         Ok(())
     }
···
     ///
     /// Returns a list of binding specifications that can be used to create
     /// actual GPUI key bindings with concrete action types.
-    pub fn get_binding_specs(&self) -> Result<Vec<BindingSpec>> {
+    pub fn get_binding_specs(&self) -> Vec<BindingSpec> {
         let mut specs = Vec::new();
 
         for keymap in &self.keymaps {
             let context = keymap.context.as_deref();
 
-            match &keymap.bindings {
-                KeyBindings::Simple(map) => {
-                    for (key, action_value) in map {
-                        let action_name = action_value.action_name()?;
-                        specs.push(BindingSpec {
-                            keystrokes: key.clone(),
-                            action_name,
-                            action_params: action_value.params(),
-                            context: context.map(String::from),
-                        });
-                    }
-                }
-                KeyBindings::Complex(entries) => {
-                    for entry in entries {
-                        let action_name = entry.action.action_name()?;
-                        let binding_context = entry.context.as_deref().or(context);
-                        specs.push(BindingSpec {
-                            keystrokes: entry.key.clone(),
-                            action_name,
-                            action_params: entry.action.params(),
-                            context: binding_context.map(String::from),
-                        });
-                    }
-                }
-            }
-        }
-
-        Ok(specs)
-    }
-
-    /// Convert this collection into boxed actions using a registry
-    ///
-    /// This is primarily for testing and validation purposes.
-    pub fn to_actions(
-        &self,
-        action_registry: &impl ActionRegistry,
-    ) -> Result<Vec<(String, Box<dyn Action>, Option<String>)>> {
-        let mut actions = Vec::new();
-
-        for spec in self.get_binding_specs()? {
-            if let Some(action) = action_registry.get_action(&spec.action_name, spec.action_params)
-            {
-                actions.push((spec.keystrokes, action, spec.context));
-            } else {
-                log::warn!("Unknown action in keymap: {}", spec.action_name);
+            for (keystrokes, action_name) in &keymap.bindings {
+                specs.push(BindingSpec {
+                    keystrokes: keystrokes.clone(),
+                    action_name: action_name.clone(),
+                    context: context.map(String::from),
+                });
             }
         }
 
-        Ok(actions)
+        specs
     }
 
     /// Get all keymaps in this collection
···
         &self.keymaps
     }
 
+    /// Add a keymap to this collection
+    pub fn add(&mut self, keymap: Keymap) {
+        self.keymaps.push(keymap);
+    }
+
     /// Clear all keymaps from this collection
     pub fn clear(&mut self) {
         self.keymaps.clear();
     }
+
+    /// Find all bindings for a given action
+    pub fn find_bindings_for_action(&self, action_name: &str) -> Vec<&BindingSpec> {
+        self.get_binding_specs()
+            .iter()
+            .filter(|spec| spec.action_name == action_name)
+            .collect()
+    }
+
+    /// Find the action for a given keystroke in a context
+    pub fn find_action(&self, keystrokes: &str, context: Option<&str>) -> Option<&str> {
+        // First try to find a binding with matching context
+        if let Some(context) = context {
+            for keymap in &self.keymaps {
+                if keymap.context.as_deref() == Some(context) {
+                    if let Some(action) = keymap.bindings.get(keystrokes) {
+                        return Some(action);
+                    }
+                }
+            }
+        }
+
+        // Then try bindings without context (global)
+        for keymap in &self.keymaps {
+            if keymap.context.is_none() {
+                if let Some(action) = keymap.bindings.get(keystrokes) {
+                    return Some(action);
+                }
+            }
+        }
+
+        None
+    }
 }
 
-/// Specification for a key binding that can be used to create actual bindings
+/// Specification for a key binding
 #[derive(Debug, Clone)]
 pub struct BindingSpec {
     /// The keystroke sequence (e.g., "cmd-s", "ctrl-shift-p")
     pub keystrokes: String,
     /// The action name to trigger
     pub action_name: String,
-    /// Optional parameters for the action
-    pub action_params: Option<serde_json::Value>,
     /// Optional context where this binding applies
     pub context: Option<String>,
 }
 
-/// Trait for registries that can provide Action instances from names
-pub trait ActionRegistry {
-    /// Get an action by name, optionally with parameters
-    fn get_action(&self, name: &str, params: Option<serde_json::Value>) -> Option<Box<dyn Action>>;
-}
-
-/// A simple action registry implementation using a HashMap
-pub struct SimpleActionRegistry {
-    actions: HashMap<String, Box<dyn Fn(Option<serde_json::Value>) -> Box<dyn Action>>>,
-}
-
-impl SimpleActionRegistry {
-    /// Create a new empty registry
-    pub fn new() -> Self {
-        Self {
-            actions: HashMap::new(),
-        }
-    }
-
-    /// Register an action factory
-    pub fn register<F>(&mut self, name: impl Into<String>, factory: F)
-    where
-        F: Fn(Option<serde_json::Value>) -> Box<dyn Action> + 'static,
-    {
-        self.actions.insert(name.into(), Box::new(factory));
-    }
-
-    /// Register a simple action (no parameters)
-    pub fn register_simple<A: Action>(&mut self, name: impl Into<String>, action: A)
-    where
-        A: Clone + 'static,
-    {
-        let name = name.into();
-        self.register(name, move |_params| Box::new(action.clone()));
-    }
-}
-
-impl ActionRegistry for SimpleActionRegistry {
-    fn get_action(&self, name: &str, params: Option<serde_json::Value>) -> Option<Box<dyn Action>> {
-        self.actions.get(name).map(|factory| factory(params))
-    }
-}
-
-/// Returns the default keymap JSON for the current platform
-pub fn default_keymap_json() -> &'static str {
-    #[cfg(target_os = "macos")]
-    {
-        include_str!("../default-keymap.json")
-    }
-
-    #[cfg(target_os = "windows")]
-    {
-        include_str!("../default-keymap-windows.json")
-    }
-
-    #[cfg(target_os = "linux")]
-    {
-        include_str!("../default-keymap-linux.json")
-    }
-
-    #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]
-    {
-        include_str!("../default-keymap.json")
-    }
-}
-
-/// Helper function to create a KeyBinding from a simple action
-pub fn binding(key: impl Into<String>, action: impl Into<String>) -> KeyBindingEntry {
-    KeyBindingEntry {
-        key: key.into(),
-        action: ActionValue::Simple(action.into()),
-        context: None,
-    }
-}
-
-/// Helper function to create a KeyBinding with context
-pub fn binding_with_context(
-    key: impl Into<String>,
-    action: impl Into<String>,
-    context: impl Into<String>,
-) -> KeyBindingEntry {
-    KeyBindingEntry {
-        key: key.into(),
-        action: ActionValue::Simple(action.into()),
-        context: Some(context.into()),
-    }
+/// Helper function to create a simple binding
+pub fn binding(key: impl Into<String>, action: impl Into<String>) -> (String, String) {
+    (key.into(), action.into())
 }
 
 #[cfg(test)]
···
 
         let keymap: Keymap = serde_json::from_str(json).unwrap();
         assert_eq!(keymap.context, Some("Editor".to_string()));
-
-        if let KeyBindings::Simple(map) = keymap.bindings {
-            assert_eq!(map.len(), 2);
-            assert!(matches!(map.get("cmd-s"), Some(ActionValue::Simple(s)) if s == "Save"));
-            assert!(matches!(map.get("cmd-z"), Some(ActionValue::Simple(s)) if s == "Undo"));
-        } else {
-            panic!("Expected simple bindings");
-        }
+        assert_eq!(keymap.bindings.len(), 2);
+        assert_eq!(keymap.bindings.get("cmd-s"), Some(&"Save".to_string()));
+        assert_eq!(keymap.bindings.get("cmd-z"), Some(&"Undo".to_string()));
     }
 
     #[test]
-    fn test_parse_complex_keymap() {
+    fn test_parse_multiple_keymaps() {
         let json = r#"[
             {
-                "bindings": [
-                    { "key": "cmd-s", "action": "Save" },
-                    { "key": "cmd-z", "action": ["Undo", { "count": 1 }] }
-                ]
+                "bindings": {
+                    "cmd-s": "Save",
+                    "cmd-z": "Undo"
+                }
+            },
+            {
+                "context": "Menu",
+                "bindings": {
+                    "enter": "Select",
+                    "escape": "Cancel"
+                }
             }
         ]"#;
 
         let keymaps: Vec<Keymap> = serde_json::from_str(json).unwrap();
-        assert_eq!(keymaps.len(), 1);
-
-        let keymap = &keymaps[0];
-        if let KeyBindings::Complex(entries) = &keymap.bindings {
-            assert_eq!(entries.len(), 2);
-
-            assert_eq!(entries[0].key, "cmd-s");
-            assert!(matches!(&entries[0].action, ActionValue::Simple(s) if s == "Save"));
-
-            assert_eq!(entries[1].key, "cmd-z");
-            assert!(matches!(&entries[1].action, ActionValue::WithParams(_)));
-        } else {
-            panic!("Expected complex bindings");
-        }
-    }
-
-    #[test]
-    fn test_action_value_methods() {
-        let simple = ActionValue::Simple("Save".to_string());
-        assert_eq!(simple.action_name().unwrap(), "Save");
-        assert_eq!(simple.params(), None);
-
-        let with_params = ActionValue::WithParams(vec![
-            serde_json::json!("Undo"),
-            serde_json::json!({ "count": 1 }),
-        ]);
-        assert_eq!(with_params.action_name().unwrap(), "Undo");
-        assert_eq!(
-            with_params.params(),
-            Some(serde_json::json!({ "count": 1 }))
-        );
+        assert_eq!(keymaps.len(), 2);
+        assert_eq!(keymaps[0].context, None);
+        assert_eq!(keymaps[1].context, Some("Menu".to_string()));
     }
 
     #[test]
···
         assert_eq!(collection.keymaps().len(), 2);
         assert_eq!(collection.keymaps()[0].context, None);
         assert_eq!(collection.keymaps()[1].context, Some("Menu".to_string()));
+
+        let specs = collection.get_binding_specs();
+        assert_eq!(specs.len(), 2);
+        assert_eq!(specs[0].keystrokes, "cmd-s");
+        assert_eq!(specs[0].action_name, "Save");
+        assert_eq!(specs[0].context, None);
+    }
+
+    #[test]
+    fn test_find_action() {
+        let mut collection = KeymapCollection::new();
+
+        collection.add(Keymap::new(
+            [("cmd-s", "Save"), ("cmd-z", "Undo")]
+                .iter()
+                .map(|(k, v)| (k.to_string(), v.to_string()))
+                .collect(),
+        ));
+
+        collection.add(Keymap::with_context(
+            "Editor",
+            [("cmd-x", "Cut")]
+                .iter()
+                .map(|(k, v)| (k.to_string(), v.to_string()))
+                .collect(),
+        ));
+
+        // Global binding
+        assert_eq!(collection.find_action("cmd-s", None), Some("Save"));
+        assert_eq!(
+            collection.find_action("cmd-s", Some("Editor")),
+            Some("Save")
+        );
+
+        // Context-specific binding
+        assert_eq!(collection.find_action("cmd-x", Some("Editor")), Some("Cut"));
+        assert_eq!(collection.find_action("cmd-x", None), None);
+        assert_eq!(collection.find_action("cmd-x", Some("Menu")), None);
     }
 
     #[test]
     fn test_serialize_keymap() {
         let mut bindings = HashMap::new();
-        bindings.insert("cmd-s".to_string(), ActionValue::Simple("Save".to_string()));
-        bindings.insert("cmd-z".to_string(), ActionValue::Simple("Undo".to_string()));
+        bindings.insert("cmd-s".to_string(), "Save".to_string());
+        bindings.insert("cmd-z".to_string(), "Undo".to_string());
 
-        let keymap = Keymap {
-            context: Some("Editor".to_string()),
-            use_key_equivalents: false,
-            bindings: KeyBindings::Simple(bindings),
-        };
+        let keymap = Keymap::with_context("Editor", bindings);
 
         let json = serde_json::to_string_pretty(&keymap).unwrap();
         let parsed: Keymap = serde_json::from_str(&json).unwrap();
 
         assert_eq!(parsed.context, keymap.context);
-        assert_eq!(parsed.use_key_equivalents, keymap.use_key_equivalents);
+        assert_eq!(parsed.bindings, keymap.bindings);
     }
 }

crates/gpuikit-keymap/test-keymap.json

···
-[
-  {
-    "context": "Editor",
-    "use_key_equivalents": true,
-    "bindings": {
-      "ctrl-t": "editor_demo::NextTheme",
-      "ctrl-l": "editor_demo::NextLanguage",
-      "alt-up": "editor_demo::MoveUp",
-      "alt-down": "editor_demo::MoveDown",
-      "cmd-d": "editor_demo::Delete",
-      "ctrl-a": "editor_demo::SelectAll"
-    }
-  }
-]

crates/gpuikit/Cargo.toml

···
 serde = { workspace = true }
 serde_json = { workspace = true }
 log = { workspace = true }
+rust-embed = { workspace = true }
 
 [dev-dependencies]
 gpui = { workspace = true, features = ["test-support"] }

crates/gpuikit/src/lib.rs

···
 
 pub mod error;
 pub mod layout;
+pub mod resource;
 
 pub mod style {
     use crate::theme::Theme;

crates/gpuikit/src/resource.rs

···
+//! Resource management for gpui apps
+//!
+//! Embed icons, images, fonts, etc...
+
+use anyhow::Result;
+use gpui::{AssetSource, SharedString};
+use rust_embed::RustEmbed;
+use std::borrow::Cow;
+
+/// Trait for types that can serve as embedded asset sources
+pub trait Resource: RustEmbed {
+    /// Get an asset by path
+    fn by_path(path: &str) -> Option<Cow<'static, [u8]>> {
+        Self::get(path).map(|file| file.data)
+    }
+
+    /// Check if an asset exists
+    fn has(path: &str) -> bool {
+        Self::get(path).is_some()
+    }
+
+    /// List all assets
+    fn list(prefix: Option<&str>) -> Vec<String> {
+        match prefix {
+            Some(prefix) => Self::iter()
+                .filter(|path| path.starts_with(prefix))
+                .map(|s| s.to_string())
+                .collect(),
+            None => Self::iter().map(|s| s.to_string()).collect(),
+        }
+    }
+}
+
+impl<T: RustEmbed> Resource for T {}
+
+pub struct ResourceSource<T: Resource + Send + Sync> {
+    _phantom: std::marker::PhantomData<T>,
+}
+
+impl<T: Resource + Send + Sync> Default for ResourceSource<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T: Resource + Send + Sync> ResourceSource<T> {
+    /// Create a new embedded asset source
+    pub fn new() -> Self {
+        Self {
+            _phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<T: Resource + Send + Sync + 'static> AssetSource for ResourceSource<T> {
+    fn load(&self, path: &str) -> Result<Option<Cow<'static, [u8]>>> {
+        Ok(T::by_path(path))
+    }
+
+    fn list(&self, prefix: &str) -> Result<Vec<SharedString>> {
+        Ok(T::list(Some(prefix))
+            .into_iter()
+            .map(|s| s.into())
+            .collect())
+    }
+}