mirror of
https://github.com/tinyhumansai/openhuman.git
synced 2026-07-29 22:23:01 +00:00
eded18a70319dff79f4170388ef99b42ecc015c7
47
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 Cyrus GrayandGitHub
|
9faef5582b |
feat(welcome): redesign sign-in page to match Figma card layout (#417)
* feat(welcome): redesign sign-in page to match Figma card layout Rebuild Welcome page using the same white-card design language as the Home page — centered container with shadow, border, and consistent spacing. Adds horizontal OAuth pill buttons (Google, GitHub, Twitter), "Or" divider, email input field, and "Continue with email" CTA. * fix(hooks): remove core crate from pre-push rust:check The root Cargo.toml includes whisper-rs-sys which fails to build on macOS due to -mcpu=native in its cmake/ggml layer. The Tauri shell crate builds fine and is the only Rust target the app ships, so scope rust:check to src-tauri only. |
||
|
github-actions[bot]
|
17c9b39f74 | chore(release): v0.51.17 | ||
|
github-actions[bot]
|
8d96f28f96 | chore(release): v0.51.16 | ||
|
github-actions[bot]
|
3361ec040f | chore(release): v0.51.15 | ||
|
github-actions[bot]
|
4dd9da88a9 | chore(release): v0.51.14 | ||
|
github-actions[bot]
|
621f862095 | chore(release): v0.51.13 | ||
|
github-actions[bot]
|
3ac6bc6a8a | chore(release): v0.51.12 | ||
|
github-actions[bot]
|
c8c0f8bb5d | chore(release): v0.51.11 | ||
|
github-actions[bot]
|
fbbdc07062 | chore(release): v0.51.10 | ||
|
github-actions[bot]
|
766ad5af48 | chore(release): v0.51.9 | ||
|
github-actions[bot]
|
32c583aafd | chore(release): v0.51.8 | ||
|
github-actions[bot]
|
36e5736814 | chore(release): v0.51.7 | ||
|
|
b589a29e77 |
Extract socket controller into dedicated domain module (#340)
* refactor: remove global_engine usage in tests and instantiate AccessibilityEngine directly - Updated the test suite to eliminate the use of global_engine, replacing it with a direct instantiation of AccessibilityEngine. - This change enhances test isolation and clarity by ensuring that each test operates with its own instance of the engine, improving reliability and maintainability. * feat: add socket module for skill communication - Introduced a new `socket` module to facilitate communication between skills, enhancing the modularity and organization of the codebase. - Updated imports in `qjs_engine.rs` to reference the new `SocketManager` from the `socket` module, streamlining socket management for skill interactions. - Removed the deprecated `socket_manager` module from the skills module, improving clarity and reducing redundancy in the code structure. * feat: integrate socket controllers and schemas into core functionality - Added socket-related registered controllers and schemas to the core build functions, enhancing the communication capabilities within the OpenHuman framework. - Updated the `build_registered_controllers` and `build_declared_controller_schemas` functions to include socket components, ensuring comprehensive integration of the new socket module. * feat: enhance QuickJS skill runtime with socket manager integration - Updated the `bootstrap_skill_runtime` function to initialize and register the `SocketManager` globally, allowing RPC handlers to access socket functionalities. - Improved documentation to reflect the addition of socket management capabilities alongside the QuickJS skill runtime. - Cleaned up imports in `event_handlers.rs` to streamline the codebase. * refactor: remove socket manager integration from skill runtime - Removed the `SocketManager` integration from the `bootstrap_skill_runtime` function, simplifying the socket management process. - Eliminated the `socket_manager` field and related methods from the `RuntimeEngine` struct, streamlining the codebase. - Cleaned up unused MCP handlers and socket-related imports in the event handlers, enhancing code clarity and maintainability. * refactor: remove sync_tools calls from skill status handling - Eliminated unnecessary calls to `sync_tools()` in the `RuntimeEngine` during skill status changes, simplifying the skill lifecycle management. - This change enhances performance by reducing redundant synchronization operations during skill execution and shutdown processes. * feat: enhance socket event handling with improved logging - Added logging for incoming socket events to improve observability, including event name and data size. - Implemented detailed debug logging for event payloads, ensuring clarity on the data being processed. - Updated event handling logic to streamline routing for webhook requests and inbound channel messages, enhancing the overall responsiveness of the system. - Introduced logging for unhandled events to aid in debugging and monitoring. * feat: enhance socket management and auto-connect functionality - Updated the `bootstrap_skill_runtime` function to clone the `SocketManager` instance for global registration, ensuring proper socket management. - Introduced background tasks for auto-starting skills and auto-connecting to the backend using stored session tokens, improving startup efficiency and user experience. - Added detailed logging for session token checks and connection attempts, enhancing observability and debugging capabilities during socket operations. * feat: enhance skill selection and tool management in tests - Introduced a new `manifests_in_dir` function to retrieve skill manifests from a specified directory, improving skill discovery. - Added `select_skill_id` function to prioritize skill selection based on environment variables and preferred candidates, enhancing flexibility in test configurations. - Updated the test suite to utilize the new skill selection logic, ensuring more robust and configurable test scenarios. - Improved handling of tool selection with enhanced logging and fallback mechanisms for better debugging and usability. * format code:wq * feat: add Rust checks and formatting commands to package.json - Introduced new scripts for Rust checks and formatting in both the main and app package.json files. - Updated pre-push hook to include Rust compile checks, enhancing pre-push validation. - Modified existing format commands to integrate Rust formatting, ensuring consistency across codebases. * fix: improve formatting of the "Keep Screenshots" label description - Adjusted the formatting of the description text for better readability by breaking it into multiple lines within the `ScreenIntelligencePanel` component. * fix: install rustls crypto provider before WebSocket TLS connect The socket auto-connect was panicking with "Could not automatically determine the process-level CryptoProvider" because tokio-tungstenite uses rustls for wss:// but no crypto provider was installed. Install the ring provider before each connect attempt. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: use dynamically selected skill in sync memory tests The tests hardcoded 'example-skill' which no longer exists in the skills directory. Now dynamically picks the first available skill (preferring server-ping) so tests work regardless of which skills are present. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com> |
||
|
Steven EnamakelandGitHub
|
e925e8a319 |
Fix local reset flow and Accessibility permission handling (#324)
* refactor: clean up imports and improve code structure in skills_cli and registry_ops - Removed unused imports in `skills_cli.rs` and `registry_ops.rs` to enhance code clarity. - Streamlined import statements for better organization and readability. - Minor adjustments in `engine.rs` to maintain consistency in import usage. * fix: update UI text and styles for MemoryWorkspace and SkillSetupWizard components - Changed the title in MemoryWorkspace to "Memory (EverMind)" for clarity. - Updated text colors in SkillSetupWizard for better visibility and consistency. - Enhanced button styles and loading indicators for improved user experience. * feat: implement reset functionality for OpenHuman data and enhance app data clearing process - Added a new utility function `resetOpenHumanDataAndRestartCore` to reset local OpenHuman data and restart the core process. - Updated `clearAllAppData` in `SettingsHome` to utilize the new reset function, improving the app's data clearing process. - Enhanced error handling during the data reset and session clearing operations to ensure robustness. - Introduced tests for the new reset functionality to validate its behavior and integration. * refactor: remove screen recording permission from AccessibilityPanel - Eliminated the screen recording permission check and associated UI elements from the AccessibilityPanel component. - Updated tests to ensure the screen recording option is no longer present in the rendered output, improving clarity and focus on relevant permissions. * chore: update package.json files to integrate Husky for Git hooks - Added Husky as a dev dependency in both package.json files to manage Git hooks. - Included "prepare" and "postinstall" scripts in the main package.json to ensure Husky is set up correctly. - Cleaned up the app's package.json by removing the "prepare" script, as it is now handled in the main package.json. - Enhanced logging in tauriCommands.ts for better debugging during the reset process. * fix: update variable name for clarity in ops.rs test assertions - Changed the variable name from `data` to `value` in the test assertions to enhance clarity and better reflect its purpose. - Ensured that the assertions remain functional and maintain the integrity of the test logic. * feat: enhance skill selection logic in skills_debug_e2e.rs - Introduced a new function `select_skill_id` to improve skill selection based on environment variables and preferred skills. - Updated the skill ID retrieval process to prioritize user-defined skills while maintaining a fallback to the default skill. - Enhanced documentation to clarify the usage of environment variables for skill testing. * format |
||
|
github-actions[bot]
|
a67379a914 | chore(release): v0.51.6 | ||
|
github-actions[bot]
|
e2e1beefe3 | chore(release): v0.51.5 | ||
|
Mega MindandGitHub
|
b7b3d62c58 |
test(e2e): skill execution flow (core RPC + Skills UI) (#283)
* test(e2e): skill execution flow (core RPC + Skills UI) - Add skill-execution-flow.spec: core.ping, skills start/list_tools/call_tool/stop via shared RPC helper, seeded QuickJS echo skill (same tree as Rust json_rpc_e2e). - Add core-rpc helpers: WebView invoke on tauri-driver, Node fetch + port probe on Appium Mac2 (no WKWebView execute). - Extend navigateViaHash with Mac2 sidebar label fallbacks for /skills, /home, etc. - Wire yarn test:e2e:skill-execution and e2e-run-all-flows. Refs: #68 Made-with: Cursor * fix(e2e): address CodeRabbit review for skill execution PR - core-rpc-node: honor OPENHUMAN_CORE_HOST and OPENHUMAN_CORE_PORT before port scan - shared-flows: Mac2 navigateViaHash for /settings/billing; throw on unmapped hash; navigateToBilling fallback without WebView execute on Mac2 - skill-e2e-runtime: javascript manifest + removeSeededEchoSkill teardown - skill-execution-flow: teardown seeded skill; document RPC shapes vs json_rpc_e2e; skip placeholder for future agent chat tool_calls Made-with: Cursor |
||
|
github-actions[bot]
|
d930c478a2 | chore(release): v0.51.4 | ||
|
github-actions[bot]
|
c1f378521d | chore(release): v0.51.3 | ||
|
github-actions[bot]
|
fa7c41cf48 | chore(release): v0.51.2 | ||
|
github-actions[bot]
|
565ed463a9 | chore(release): v0.51.1 | ||
|
github-actions[bot]
|
5bf78c3a81 | chore(release): v0.51.0 | ||
|
|
2545ae374a |
refactor: extract accessibility middleware module (#184)
* feat(autocomplete): add target_role to EngineState for improved context validation - Introduced a new field `target_role` in `EngineState` to store the AXRole of the text element when suggestions are generated. - Updated the `AutocompleteEngine` to validate the focused element against the expected app and role before applying suggestions. - Enhanced the `apply_text_to_focused_field` function to include role validation, ensuring better accuracy in text insertion. - Improved the handling of suggestion context and error states during autocomplete operations. This update enhances the reliability of the autocomplete feature by ensuring that suggestions are applied only when the correct context is maintained. * fix(package): update dev:app script to include core staging step - Modified the `dev:app` script in `package.json` to run `yarn core:stage` before executing `tauri dev`, ensuring that the core sidecar is properly staged during development. - This change enhances the development workflow by automating the staging process, reducing manual steps for developers. This update improves the reliability of the development environment setup. * feat(autocomplete): implement core autocomplete engine and supporting modules - Introduced a new `AutocompleteEngine` struct to manage the state and operations of the autocomplete feature, including starting, stopping, and refreshing suggestions. - Added `EngineState` to track the current status, phase, and context of the autocomplete process. - Implemented helper functions for managing focus and overlay notifications, enhancing user interaction with suggestions. - Created utility functions for terminal context extraction and text sanitization, improving the accuracy of suggestions. - Developed a comprehensive set of types and structures to support autocomplete operations, including suggestion handling and status reporting. This update lays the foundation for a robust autocomplete feature, enhancing user experience through improved context awareness and interaction. * refactor(autocomplete): remove unused functions and improve clipboard handling - Deleted the `normalize_ax_value` and `parse_ax_number` functions as they were not utilized in the codebase, streamlining the autocomplete module. - Enhanced the `clipboard_save` function to improve readability by formatting the string conversion of clipboard output, ensuring better handling of empty or "missing value" cases. This update simplifies the code and improves the overall maintainability of the autocomplete functionality. * refactor(autocomplete): remove unused functions and improve clipboard handling - Deleted the `normalize_ax_value` and `parse_ax_number` functions as they were not utilized in the codebase, streamlining the autocomplete module. - Enhanced the `clipboard_save` function to improve readability by formatting the string conversion of clipboard output, ensuring better handling of empty or "missing value" cases. This update cleans up the code and optimizes the clipboard handling logic for the autocomplete feature. * feat(autocomplete): enhance focus handling and text insertion methods - Implemented a unified Swift helper for querying focused text elements, improving performance and reliability on macOS. - Added fallback mechanisms to use osascript for focus queries when the helper is unavailable, ensuring consistent functionality. - Refactored text insertion logic to prioritize the unified helper, with osascript and AXValue as fallback options, enhancing user experience during text application. - Cleaned up and organized focus-related functions, improving code readability and maintainability. This update significantly enhances the autocomplete feature's ability to interact with focused text elements, providing a more robust and responsive user experience. * feat(accessibility): introduce comprehensive accessibility module for macOS - Added a new `accessibility` module that centralizes focus queries, screen capture, key state detection, and permission management for macOS. - Implemented a unified Swift helper process to enhance performance and reliability in querying focused text elements and managing overlays. - Introduced various functionalities including screen capture, text insertion into focused fields, and permission detection for accessibility features. - Enhanced user experience by providing robust methods for interacting with accessibility APIs, ensuring consistent behavior across different contexts. This update significantly improves the accessibility capabilities of the application, providing a more responsive and user-friendly interface for macOS users. * feat(accessibility): introduce screen capture and focus query modules - Added a new `accessibility` module to centralize platform-specific accessibility functionalities, including screen capture and focus queries. - Implemented `capture.rs` for screen capture using platform-native tools, supporting both windowed and fullscreen modes. - Developed `focus.rs` to handle accessibility focus queries, utilizing a unified Swift helper for improved performance on macOS. - Introduced helper functions for managing overlays and permissions, enhancing user interaction and accessibility features. This update significantly enhances the application's accessibility capabilities, providing robust tools for screen capture and focus management. * refactor(accessibility): remove unused accessibility functions and streamline modules - Deleted unused functions from the accessibility module, including `focused_text_context`, `is_text_role`, `normalize_ax_value`, and `parse_ax_number`, to enhance code clarity and maintainability. - Updated module documentation to reflect the current structure and purpose, ensuring consistency across the accessibility and screen intelligence modules. This update simplifies the codebase and improves the overall organization of accessibility-related functionalities. * feat(image-processing): implement image compression and resizing for vision LLM - Added a new module `image_processing` to handle the compression and resizing of screenshots before sending them to the vision LLM. - Implemented the `compress_screenshot` function, which decodes PNG data-URIs, resizes images to fit within a specified maximum dimension, and re-encodes them as JPEGs. - Updated the `AccessibilityEngine` to utilize the new image processing functionality, ensuring that images sent for analysis are optimized for size and quality. - Introduced new dependencies in `Cargo.toml` for image handling and compression. This update enhances the efficiency of image processing in the application, reducing token usage and improving inference speed. * feat(tests): add end-to-end tests for screen intelligence vision pipeline - Introduced a new test file `screen_intelligence_vision_e2e.rs` to validate the complete flow of the screen intelligence vision pipeline. - Implemented tests that cover generating images, compressing and resizing them, simulating LLM responses, and persisting results to memory. - Utilized temporary directories and environment variable management to ensure test isolation and reliability. - Enhanced the testing framework by including helper functions for image creation and mock responses, improving the overall test coverage and robustness. This update significantly strengthens the testing capabilities of the screen intelligence module, ensuring that the entire pipeline functions correctly under various scenarios. * style: apply cargo fmt and import ordering fixes Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(accessibility): add non-macOS stub for validate_focused_target The function was gated with #[cfg(target_os = "macos")] but exported unconditionally from mod.rs, causing compilation failure on non-macOS. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * feat(accessibility): enhance screen capture and error handling - Updated the screen capture functionality to include a timestamp helper in the documentation. - Improved error handling when reading resized screenshots, ensuring temporary files are removed on failure. - Added logging for raw errors returned by the helper in the focus context, providing better debugging information. - Refactored clipboard handling in the paste functionality to preserve multi-line text, enhancing usability. - Introduced a constant for terminal application names to simplify terminal detection logic. This update improves the robustness and clarity of the accessibility module, enhancing both screen capture and focus handling capabilities. --------- Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com> |
||
|
github-actions[bot]
|
7fd45682eb | chore(release): v0.50.3 | ||
|
github-actions[bot]
|
cf6f077502 | chore(release): v0.50.2 | ||
|
github-actions[bot]
|
c4b5474643 | chore(release): v0.50.1 | ||
|
github-actions[bot]
|
270d0008e2 | chore(release): v0.50.0 | ||
|
github-actions[bot]
|
48272e47d3 | chore(release): v0.49.32 | ||
|
github-actions[bot]
|
3e756d958a | chore(release): v0.49.31 | ||
|
github-actions[bot]
|
e65432ea1d | chore(release): v0.49.30 | ||
|
github-actions[bot]
|
9117db458a | chore(release): v0.49.29 | ||
|
github-actions[bot]
|
0bb8ef4edb | chore(release): v0.49.28 | ||
|
github-actions[bot]
|
cbb8b312a5 | chore(release): v0.49.27 | ||
|
github-actions[bot]
|
cc70dd2104 | chore(release): v0.49.26 | ||
|
github-actions[bot]
|
e2820180ba | chore(release): v0.49.25 | ||
|
github-actions[bot]
|
419ffb1731 | chore(release): v0.49.24 | ||
|
github-actions[bot]
|
c7bd2bc063 | chore(release): v0.49.23 | ||
|
github-actions[bot]
|
bfd0eb6af8 | chore(release): v0.49.22 | ||
|
github-actions[bot]
|
120ea59d36 | chore(release): v0.49.21 | ||
|
Steven EnamakelandGitHub
|
14dc860a21 |
Skills runtime, onboarding, deep links, and core RPC refinements (#95)
* feat(telegram): implement Telegram channel and attachment handling - Added `TelegramChannel` struct for managing Telegram Bot API interactions, including user management and message handling. - Introduced attachment parsing with `TelegramAttachment` and `TelegramAttachmentKind` to support various media types. - Implemented functions for parsing attachment markers and validating URLs, enhancing message processing capabilities. - Created a new module structure for Telegram, including `attachments`, `channel`, and `text` for better organization and maintainability. * feat(skills): implement skills registry management and E2E testing - Added functionality for fetching, searching, installing, and uninstalling skills from a remote registry. - Introduced new modules for registry operations and types, enhancing the skills management system. - Implemented E2E tests for skills registry interactions, ensuring robust functionality and integration. - Updated documentation to reflect new skills registry features and usage instructions. * refactor(coreRpcClient): remove socket RPC handling and streamline HTTP request logging - Eliminated socket-based RPC handling to simplify the core RPC client logic. - Updated logging to use a unified debug logger for both HTTP requests and errors. - Improved error handling for HTTP responses to ensure clarity in error reporting. * feat(skills): enhance skill setup handling and improve error management - Updated SkillActionButton to directly open the setup modal for skills requiring OAuth, bypassing the QuickJS runtime. - Enhanced SkillSetupWizard to handle OAuth configuration more effectively, ensuring smoother transitions during skill setup. - Improved error handling during skill startup and setup processes, providing clearer logging for failures. - Refactored skills loading logic in the Skills page to prioritize registry-based skill fetching, with fallback to runtime discovery. - Added skill installation handling in the Skills page, allowing for better user feedback during installation processes. * feat(deep-link): enhance OAuth handling and streamline token management - Updated desktopDeepLinkListener to improve skill connection handling after OAuth completion. - Introduced setSkillSetupComplete action to mark skills as connected immediately post-OAuth. - Refactored token fetching logic to ensure encrypted tokens are stored correctly, enhancing error handling and reducing redundant checks. - Added new permissions in default.json for improved window management capabilities. * feat(skills): enhance skill management with global engine and runtime controllers - Added global engine management for skill runtime access, allowing RPC handlers to interact with the runtime engine. - Introduced new runtime controllers for skills, including start, stop, status, setup_start, list_tools, sync, and call_tool, enhancing skill lifecycle management. - Updated schemas to include new skill controller functionalities, improving the overall skills management system. - Enhanced documentation and comments for clarity on new features and usage. * refactor(skills): update global engine management and enhance documentation - Replaced OnceLock with RwLock for the global RuntimeEngine, allowing for better testability and flexibility in engine management. - Updated the global_engine and require_engine functions to return cloned Arc references, improving usability. - Enhanced documentation comments for clarity on the global engine's usage and behavior in production and testing scenarios. * chore(todos): update TODO list with removal of Tauri from Rust core - Added a new item to the TODO list indicating the need to remove Tauri from the OpenHuman Rust core, streamlining the project structure. * feat(onboarding): revamp onboarding steps and introduce local AI model consent - Replaced the PrivacyStep with a new ScreenPermissionsStep to handle accessibility permissions. - Added LocalAIStep for user consent on local AI model usage and download initiation. - Introduced SkillsStep and ToolsStep for selecting skills and enabling tools during onboarding. - Updated onboarding state management to include local model consent, download status, and enabled tools. - Enhanced the overall onboarding flow with new components and improved user experience. * feat(onboarding): enhance onboarding flow with new WelcomeStep and updated LocalAIStep - Introduced a new WelcomeStep to guide users through the onboarding process. - Updated LocalAIStep to clarify local AI model usage and consent, including improved messaging on privacy and resource impact. - Enhanced ScreenPermissionsStep to emphasize local processing of accessibility data. - Adjusted total steps in onboarding to reflect the addition of the WelcomeStep, improving user experience. * refactor(tray): remove tray integration and related functionalities - Deleted the tray module and its associated operations, streamlining the project structure. - Removed references to Tauri app handle in various components, transitioning to a memory client for skill data persistence. - Updated skill instances and event loops to eliminate dependencies on tray functionalities, enhancing modularity. - Improved documentation to reflect the removal of tray-related features and clarify the new architecture. * feat(onboarding): introduce OnboardingOverlay and enhance onboarding flow - Added OnboardingOverlay component to display the onboarding process as a full-screen overlay when the user is not onboarded. - Updated the Onboarding component to include a new MnemonicStep for recovery phrase management. - Enhanced onboarding state management to track workspace onboarding flags and user onboarding status. - Refactored AppRoutes to streamline routing and integrate the new onboarding flow. - Removed deprecated onboarding logic from previous steps, improving overall user experience. * refactor(sidebar): simplify hidden paths and update ProtectedRoute tests - Removed '/onboarding' from the hiddenPaths in MiniSidebar to streamline route visibility. - Updated ProtectedRoute tests to reflect changes in onboarding handling, ensuring children render correctly when authenticated. * chore: format, fix E2E lint, and onboarding step polish Made-with: Cursor * style(onboarding): update background color for onboarding steps - Changed background color from black/30 to stone-900 for improved visual consistency across LocalAIStep, MnemonicStep, ScreenPermissionsStep, SkillsStep, ToolsStep, and WelcomeStep components. - Enhanced overall aesthetics of the onboarding flow. * fix(tests): update variable naming and comment out unused JavaScript content - Renamed workspace variable to `_ws` to indicate it is unused in the `test_registry_cache_ttl_expired` test. - Commented out the `js_content` variable to prevent unused variable warnings in the test setup. * refactor(tests): streamline JSON-RPC test setup and remove unused backend URL handling - Updated the JSON-RPC end-to-end test to always use the in-process Axum mock for backend settings, ensuring consistent test behavior. - Removed the conditional logic for external backend URLs, simplifying the test setup. - Ensured proper cleanup of mock join handles after test execution. * refactor(runtime): update skill startup process to use core RPC - Replaced the direct call to `runtimeStartSkill` with a `callCoreRpc` method for starting skills, enhancing the integration with the core RPC system. - Updated comments to reflect the new implementation details. - Made minor adjustments to the schema organization in Rust for better clarity on runtime controllers. |
||
|
github-actions[bot]
|
680bd8cdad | chore(release): v0.49.20 | ||
|
github-actions[bot]
|
5d95abe4c7 | chore(release): v0.49.19 | ||
|
github-actions[bot]
|
1060ab8925 | chore(release): v0.49.18 | ||
|
Steven Enamakel
|
5d865fa4e2 |
Update version to 0.49.17 across multiple files
- Bumped the version of the "openhuman" package in Cargo.lock and Cargo.toml to 0.49.17. - Updated the version in app/package.json and app/src-tauri/Cargo.toml to reflect the new release. - Adjusted the version in app/src-tauri/tauri.conf.json for consistency across the application. |
||
|
Steven EnamakelandGitHub
|
7bcf43314a |
Improve service lifecycle E2E coverage and align CI workflows (#62)
* Add JSON-RPC schema definition and HTTP schema endpoint - Introduced a new `schema.json` file containing detailed definitions for various JSON-RPC methods, including their inputs, outputs, and descriptions. - Implemented a new HTTP endpoint `/schema` in the core server to serve the JSON-RPC schema, enhancing API documentation and accessibility. - Updated the core HTTP router to include the new schema route, improving the overall structure and usability of the API. - Enhanced error handling and response formatting in the server to ensure consistent feedback for schema requests. * Update TypeScript configuration and refactor core RPC client - Changed TypeScript target from ES2020 to ESNext and updated library references in `tsconfig.json` for improved compatibility with modern features. - Refactored `coreRpcClient.ts` to enhance JSON-RPC request handling, including the introduction of legacy method aliases and improved error handling. - Updated API service methods in `authApi.ts` and `channelConnectionsApi.ts` to utilize the new core RPC client structure, streamlining authentication and channel connection processes. - Added new utility functions for managing JSON-RPC requests and responses, improving code organization and maintainability. - Enhanced test coverage for the new RPC client methods and refactored existing tests to align with the updated structure. * Enhance Tauri configuration and refactor daemon program arguments - Updated `tauri.conf.json` to include additional macOS infoPlist settings for better application identification and icon management. - Refactored the `daemon_program_args` function in `common.rs` to improve clarity by renaming the parameter to `_exe`, indicating it is unused. This change enhances code readability and maintainability. * Refactor Tauri configuration by removing unused macOS infoPlist settings - Updated `tauri.conf.json` to streamline macOS configuration by removing unnecessary infoPlist entries while retaining essential settings for the application. - This change enhances clarity and maintainability of the Tauri configuration file. * Enhance authentication flow and testing documentation - Introduced a new `isAuthBootstrapComplete` state in the authentication slice to manage the completion of the authentication bootstrap process. - Updated the `UserProvider` to set the `isAuthBootstrapComplete` state based on the authentication status, improving session restoration logic. - Modified route components (`DefaultRedirect`, `ProtectedRoute`, `PublicRoute`) to conditionally render based on the `isAuthBootstrapComplete` state, enhancing user experience during the authentication process. - Added a comprehensive testing guide in `CLAUDE.md`, detailing unit and E2E testing practices, including setup, authoring rules, and a checklist for test coverage. - Updated the `SettingsHome` component to redirect to the home page instead of the login page upon logout, streamlining user navigation. - Enhanced the `LocalModelPanel` to track download progress and manage local AI assets more effectively, improving overall functionality. * Add resolutions for @tauri-apps/api dependency in package.json - Introduced a resolutions field in package.json to enforce the use of @tauri-apps/api version 2.10.1, ensuring compatibility across workspaces. - Updated dependencies in app/package.json to include @tauri-apps/api version 2.10.1, aligning with the new resolution. - Adjusted yarn.lock to reflect the updated version of @tauri-apps/api, enhancing dependency management and consistency. * Refactor Tauri configuration and enhance E2E build process - Updated `tauri.conf.json` to remove unused resource paths, streamlining the configuration for better maintainability. - Modified `wdio.conf.ts` to improve application path resolution for macOS, allowing for multiple bundle base checks to enhance compatibility. - Refactored `e2e-build.sh` to disable updater artifacts for E2E builds and introduced a conditional cargo clean mechanism, improving build efficiency and clarity. * Enhance E2E testing setup and documentation - Updated `CLAUDE.md` to clarify the default behavior of `OPENHUMAN_WORKSPACE` in `e2e-run-spec.sh`, emphasizing automatic creation and cleanup for reproducible E2E runs. - Modified `e2e-run-spec.sh` to implement automatic temporary workspace creation when `OPENHUMAN_WORKSPACE` is not set, improving usability for debugging and testing. - Enhanced cleanup logic in `e2e-run-spec.sh` to ensure proper removal of temporary workspaces after tests, contributing to a cleaner testing environment. * Implement shared mock backend for testing and enhance documentation - Introduced a shared mock backend for unit and integration tests, allowing for deterministic API behavior across app and Rust tests. - Updated `CLAUDE.md` to include detailed instructions on using the shared mock backend, including key admin endpoints and manual run commands. - Modified `package.json` to add scripts for running the mock API server and Rust tests with the mock backend. - Refactored test setup to utilize the new mock backend, improving test reliability and isolation. - Removed obsolete MSW handlers and server setup, streamlining the testing framework. * Enhance authentication state management and testing coverage - Introduced `isAuthBootstrapComplete` state in the authentication slice to track the completion of the authentication process. - Updated `ProtectedRoute` and `PublicRoute` components to utilize the new state, improving user experience during authentication. - Enhanced test cases for `ProtectedRoute` and `PublicRoute` to reflect the updated authentication state structure. - Added a new end-to-end test for the authentication flow, ensuring proper handling of OAuth tokens and session management. - Improved mock setup in tests to better simulate authentication scenarios, enhancing test reliability and coverage. * Enhance README.md with architecture overview and component roles - Added detailed descriptions of the OpenHuman architecture, highlighting the separation of business logic and UI components. - Explained the roles of Rust and the UI in the monorepo, including the use of JSON-RPC, QuickJS, Vite, React, and Tauri. - Documented the structure of controllers and the RPC surface, emphasizing the shared contract for automation and testing. - Provided links to further documentation for architecture, frontend structure, and Tauri commands. * Integrate ServiceBlockingGate component and enhance loading states - Added the `ServiceBlockingGate` component to manage service availability and display appropriate loading screens. - Updated `DefaultRedirect`, `ProtectedRoute`, and `PublicRoute` components to show a loading indicator while authentication bootstrap is in progress. - Implemented timeout handling in `UserProvider` for improved authentication state management. - Introduced tests for `ServiceBlockingGate` to ensure proper rendering and functionality under various service states. * Implement core RPC URL resolution and default hash route handling - Added a function to resolve the core RPC URL based on the environment, improving flexibility for Tauri and non-Tauri contexts. - Introduced a default hash route handler in the main application entry point to ensure proper navigation behavior. - Updated the core RPC command to expose the resolved RPC URL, enhancing the integration with the frontend. - Refactored the core RPC client to utilize the new URL resolution logic, ensuring consistent API calls. * Refactor backend URL usage to API_BASE_URL - Replaced all instances of BACKEND_URL with API_BASE_URL across various components and services to standardize API endpoint references. - Updated OAuth provider configurations, settings panels, hooks, and services to ensure consistent API calls. - Enhanced test setups to reflect the new API_BASE_URL, improving test reliability and alignment with the updated configuration. * Implement RouteLoadingScreen for improved loading states - Introduced a new `RouteLoadingScreen` component to provide a consistent loading experience across various routes. - Updated `DefaultRedirect`, `ProtectedRoute`, and `PublicRoute` components to utilize `RouteLoadingScreen` while waiting for authentication bootstrap completion. - Enhanced `MiniSidebar` to hide on additional public/setup routes, improving user navigation experience. - Refactored `UserProvider` to streamline authentication state management by removing unnecessary references. * Add feature design workflow section to CLAUDE.md - Introduced a comprehensive workflow for feature design, outlining steps from specification to UI implementation and testing. - Emphasized the importance of grounding designs in existing codebases and defined planning rules for E2E scenarios. - Provided detailed instructions for implementing features in Rust, conducting JSON-RPC tests, and building UI components in the Tauri app. * Refactor backend URL handling and improve OAuth flow - Replaced static API_BASE_URL references with dynamic backend URL resolution across various components and services, enhancing flexibility for Tauri and non-Tauri environments. - Updated OAuth provider configurations to utilize the new backend URL logic, ensuring consistent login URL generation. - Refactored API client and socket service to fetch the backend URL dynamically, improving reliability in different deployment contexts. - Introduced a new service for resolving the backend URL, streamlining the configuration and enhancing test setups. * Add debug logging guidelines to CLAUDE.md - Introduced comprehensive guidelines for implementing development-oriented debug logging in both Rust and the app. - Emphasized the importance of logging at appropriate levels (`debug`/`trace`) and following existing patterns for consistency. - Provided instructions on avoiding sensitive information in logs and ensuring terminal output is grep-friendly for easier debugging during development. * Enhance service management with new mock functionality and E2E tests - Added a mock service manager to facilitate deterministic service behavior during end-to-end tests, enabling better simulation of service states. - Introduced new buttons in the `ServiceBlockingGate` component for restarting and uninstalling services, improving user control over service management. - Implemented a comprehensive E2E test suite for the service connectivity flow, covering installation, starting, stopping, restarting, and uninstalling services. - Updated package scripts to include a new E2E test for service connectivity, enhancing testing coverage and reliability. - Refactored service operations to support mock functionality, ensuring consistent behavior across testing and production environments. * Enhance ServiceBlockingGate with improved logging and periodic health polling - Introduced periodic health polling in the `ServiceBlockingGate` component to refresh service status every 3 seconds, enhancing responsiveness to service state changes. - Added detailed logging for various operations, including service status checks and error handling, to improve traceability and debugging. - Updated E2E tests to include logging steps for better visibility during service connectivity flow tests. - Refactored error handling to ensure consistent logging of error messages across service operations. * Refactor E2E testing scripts and enhance CLAUDE.md documentation - Updated paths in CLAUDE.md to reflect the new location of the E2E run script, ensuring accurate instructions for running tests. - Removed outdated E2E test scripts from package.json and migrated relevant functionality to app/package.json for better organization. - Introduced new E2E testing scripts for specific flows (auth, login, payment, etc.) to streamline testing processes and improve modularity. - Added a script to run all E2E flows sequentially, enhancing test coverage and simplifying execution. - Improved documentation for E2E testing procedures in CLAUDE.md, providing clearer guidance for developers. * Refactor imports and enhance code readability - Removed duplicate import of `ServiceBlockingGate` in `App.tsx` for cleaner code. - Improved readability in `MiniSidebar.tsx` by formatting conditional statements. - Reordered imports in `PublicRoute.tsx` for consistency. - Enhanced formatting in `ServiceBlockingGate.tsx` for better clarity in asynchronous operations. - Streamlined import statements in various test files and components for improved organization. - Updated `LocalModelPanel.tsx` to enhance button disable logic readability. - Refactored CORS headers in `jsonrpc.rs` for better formatting. * ci: align build and test workflows with app workspace e2e * ci: align release and typecheck workflows with current workspace * Enhance ServiceBlockingGate functionality with improved refresh options - Introduced a new `RefreshOptions` type to customize the behavior of the `refreshStatus` function, allowing for conditional error clearing and status checking. - Updated the `refreshStatus` function to utilize the new options, enhancing control over service state updates. - Modified the button click handler to pass the new options, improving user experience during service refresh operations. - Adjusted state updates to prevent unnecessary re-renders and maintain consistency in service state management. * Refactor RefreshOptions type for improved clarity in ServiceBlockingGate - Consolidated the definition of the `RefreshOptions` type into a single line for better readability. - Maintained existing functionality while enhancing code clarity in the `ServiceBlockingGate` component. |
||
|
Steven EnamakelandGitHub
|
244702d349 |
Feat/refactor UI code (#52)
* Enhance autocomplete functionality and settings panel
- Added a new AutocompletePanel component for managing inline autocomplete settings, including options for enabling/disabling, debounce timing, and style configurations.
- Integrated autocomplete status tracking and logging within the panel to provide real-time feedback on the autocomplete engine's state.
- Updated settings navigation to include the new autocomplete settings route, improving user accessibility to autocomplete features.
- Introduced new Tauri commands for managing autocomplete operations, including start, stop, and current status retrieval, enhancing interaction with the autocomplete engine.
- Refactored existing code to streamline autocomplete-related functionalities and improve overall maintainability.
* Update TypeScript configuration and add new assets
- Modified `tsconfig.json` to adjust path aliases and include directories for improved module resolution.
- Added new SVG and image assets to the public directory, enhancing the application's visual resources.
- Introduced multiple Lottie animation JSON files for dynamic UI elements, expanding the application's animation capabilities.
* Update project structure and paths for Tauri integration
- Adjusted paths in the pull request template and various workflow files to reflect the new project structure, moving Tauri-related files under the `app` directory.
- Updated commands in the build and release workflows to ensure compatibility with the new file locations.
- Enhanced the test workflow to create the necessary `.env` file in the correct directory for end-to-end testing.
- Added new markdown files for agent prompts and configuration, establishing a foundation for OpenHuman's AI capabilities.
* Refactor project paths and update configurations for Tauri integration
- Adjusted script paths in package.json to reflect the new project structure, ensuring compatibility with the updated directory layout.
- Modified tsconfig.json to correct path aliases and include directories for improved module resolution.
- Introduced a new utility for resolving development paths, enhancing the ability to locate the `rust-core/ai` directory across different project structures.
- Updated Cargo.toml and tauri.conf.json to align with the new directory structure, ensuring proper resource and dependency management.
- Added a new dev_paths module to streamline path resolution logic, improving maintainability and clarity in the codebase.
* Refactor project structure and update configurations for Tauri integration
- Adjusted paths in .gitignore, Cargo.toml, and various scripts to reflect the new directory layout, moving Tauri-related files under the `app` directory.
- Introduced a new package.json file to manage workspace scripts and dependencies effectively.
- Updated end-to-end build and run scripts to ensure compatibility with the new project structure.
- Enhanced documentation in CONTRIBUTING.md to guide contributors on the updated project organization and Tauri command usage.
* Refactor Tauri command invocations to use dedicated utility functions
- Replaced direct `invoke` calls with utility functions from `tauriCommands` for improved readability and maintainability across multiple components.
- Updated `SkillsGrid`, `Skills`, `SkillProvider`, and `SkillManager` to utilize the new command structure, enhancing consistency in Tauri command handling.
- Introduced a new `coreRpcClient` for managing core RPC relay requests, streamlining error handling and request processing.
- Added a new `core_rpc_relay` command in the Tauri backend to facilitate communication with the core service, ensuring better service management and error reporting.
* Refactor Tauri command invocations in intelligence stats and memory manager
- Replaced direct `invoke` calls with utility functions from `tauriCommands` in `useIntelligenceStats` and `MemoryManager` for improved readability and maintainability.
- Updated the `aiListMemoryFiles`, `aiReadMemoryFile`, and `aiWriteMemoryFile` functions to utilize the new command structure, enhancing consistency in Tauri command handling.
- Introduced new command handling in the Rust backend for `ai.list_memory_files`, `ai.read_memory_file`, and `ai.write_memory_file`, streamlining communication with the core service.
* Refactor SkillsGrid and remove SelfEvolveModal component
- Removed the SelfEvolveModal component to streamline the SkillsGrid functionality.
- Updated the SkillsGrid to utilize the runtimeDiscoverSkills function for loading skills, replacing the previous invoke method.
- Simplified the skill entry normalization process by integrating it directly into the skills loading logic.
- Enhanced error handling during skill loading to improve robustness and user feedback.
* Refactor Tauri command invocations to use coreRpcClient
- Replaced direct `invoke` calls with `callCoreRpc` in various components, including `useIntelligenceStats`, `MemoryManager`, `SessionManager`, and `transcript` functions, enhancing code readability and maintainability.
- Updated the Rust backend to handle new command structures for memory and session management, streamlining communication with the core service.
- Improved consistency in handling Tauri commands across the application.
* Refactor Tauri command invocations to utilize coreRpcClient
- Replaced direct `invoke` calls with `callCoreRpc` in `tauriCommands.ts` and `tauriSocket.ts`, enhancing code readability and maintainability.
- Updated the Rust backend to support new command structures for authentication and session management, streamlining communication with the core service.
- Removed legacy socket reporting methods in `tauriSocket.ts`, reflecting a shift towards event-driven socket state management.
- Improved consistency in handling Tauri commands across the application, aligning with recent refactoring efforts.
* Remove pre-commit hook and update TODO list with completed tasks and new objectives. This includes separating the binary from the Tauri codebase, integrating accessibility service installation, and removing Android/iOS support from the codebase.
* Add core server functionality with dispatch and RPC handling
- Introduced new modules for core server operations, including dispatching RPC requests and handling various AI and memory-related commands.
- Implemented a robust structure for managing authentication, configuration, and session states through the `openhuman` namespace.
- Added helper functions for loading configurations, managing memory files, and processing authentication profiles.
- Established a new routing system using Axum for handling HTTP requests, including health checks and RPC endpoints.
- Enhanced error handling and logging throughout the new functionalities to improve maintainability and user feedback.
* Implement core server CLI and modular structure
- Introduced a new CLI module for the core server, enabling various commands for server management, health checks, and configuration settings.
- Established a modular structure for core server functionalities, including dispatching RPC requests and managing settings for models, memory, and runtime.
- Added comprehensive tests to validate the functionality of accessibility and autocomplete commands, ensuring robust error handling and schema compliance.
- Enhanced the overall organization of the core server codebase, improving maintainability and readability.
* Implement AI RPC dispatch functionality
- Introduced a new `ai_rpc` module for handling various AI-related commands, including memory file operations and session management.
- Enhanced the `try_dispatch` function to support commands such as listing, reading, writing memory files, and managing session states.
- Updated the core server dispatch module to integrate the new AI RPC functionality, improving modularity and maintainability.
- Refactored existing code to ensure consistent parameter parsing and error handling across AI commands.
* Update TODO list and refactor Rust core server files
- Added new tasks to the TODO list for documentation updates and feature flag cleanup.
- Introduced `Arc` import in `cli.rs` for improved concurrency handling.
- Cleaned up imports in `helpers.rs` and added conditional compilation for `tauri-host`.
- Removed unused `value_only` function in `types.rs` and added `#[allow(dead_code)]` to `SocketConnectParams` and `SocketEmitParams`.
- Enhanced `try_dispatch` function in `dispatch/mod.rs` for non-tauri-host scenarios.
- Updated `try_dispatch` in `openhuman/platform.rs` to correctly handle session parameters.
- Modified `screen_intelligence` configuration in tests to include new properties for better session management.
* Refactor import statements and enhance code readability
- Cleaned up import statements across multiple files for improved organization and consistency.
- Reformatted code in `cli.rs`, `helpers.rs`, and various dispatch modules to enhance readability.
- Ensured consistent parameter handling in `try_dispatch` functions, improving maintainability.
- Removed unnecessary whitespace and adjusted formatting for better code clarity.
* Refactor project structure and enhance AI memory management
- Consolidated the `openhuman-core` package into a single `Cargo.toml` file, removing the previous `rust-core` directory.
- Introduced new modules for AI memory management, including filesystem-based storage and encryption functionalities.
- Added Tauri commands for initializing memory and session management, enhancing user interaction with memory files.
- Implemented JSON-based storage for memory chunks and session transcripts, improving data accessibility and organization.
- Updated dependencies and features in `Cargo.toml` to support new functionalities and ensure compatibility.
* Update build and release workflows to reflect project structure changes
- Adjusted paths in GitHub Actions workflows to accommodate the consolidation of the `openhuman-core` package into a single `Cargo.toml`.
- Updated import statements in various files to point to the new locations of markdown resources.
- Modified the Tauri configuration to reflect the new resource paths, ensuring proper access to AI prompts.
- Enhanced the staging script to build the standalone binary from the updated project structure.
* Refactor AI directory resolution and update documentation
- Updated the logic for resolving AI directory paths to reflect the new project structure, replacing references to `rust-core/ai` with `src/ai/prompts`.
- Enhanced the `find_ai_directory` function across multiple modules to utilize the new path resolution methods.
- Updated documentation comments to clarify the new directory structure and fallback mechanisms for loading AI prompts.
* Rename `openhuman-core` to `openhuman` across the project
- Updated package names in `Cargo.toml` and `Cargo.lock` to reflect the new naming convention.
- Adjusted references in GitHub Actions workflows and scripts to use the new package name.
- Modified CLI command names and error messages to align with the updated naming.
- Ensured consistency in executable file names and paths throughout the codebase.
* Refactor project commands and update package scripts
- Updated package.json to change workspace references from `openhuman` to `app` for build, compile, dev, format, lint, and test scripts.
- Removed outdated memory and chat command files to streamline the codebase and improve maintainability.
- Adjusted the `lib.rs` file to reflect changes in memory command handling, transitioning to use `callCoreRpc` for Neocortex memory operations.
- Cleaned up the commands module by removing unused imports and consolidating functionality.
* Add Tauri host support and new daemon configuration
- Introduced new modules for Tauri host functionality, including `desktop` and `daemon_host`.
- Added static variables and initialization functions for managing the desktop app handle and resource directory.
- Updated import paths for `HeartbeatEngine` to improve clarity and organization.
- Implemented configuration loading and saving for daemon UI preferences, enhancing user experience.
* Update package names in project configuration
- Changed workspace references in package.json from `app` to `openhuman-app` for consistency.
- Updated the name field in the app's package.json to reflect the new naming convention.
* Remove Tauri host feature flags from core server modules
- Eliminated conditional compilation for Tauri host in `lib.rs`, `helpers.rs`, and `dispatch` modules.
- Streamlined socket management functions and dispatch logic by removing unused code related to Tauri host.
- Improved code clarity and maintainability by consolidating socket-related functionality.
* Enhance Tauri host feature integration and update dependencies
- Added `tauri-host` as a default feature in `Cargo.toml` to streamline feature management.
- Removed explicit feature flag from `openhuman` dependency in `app/src-tauri/Cargo.toml` for cleaner configuration.
- Updated Tauri command attributes in various modules to conditionally compile with the `tauri-host` feature, improving modularity.
- Expanded TODO list to include migration support from OpenClaw, indicating future development focus.
* Refactor authentication and credential management in OpenHuman
- Introduced new modules for handling authentication profiles and tokens, including `anthropic_token`, `openai_oauth`, and `profiles`.
- Removed unused Tauri host-related code from core server modules, enhancing clarity and maintainability.
- Updated `Cargo.toml` and `Cargo.lock` to reflect the removal of the `rquickjs` dependency and other package adjustments.
- Streamlined memory client initialization in dispatch logic to utilize the new `local_memory` module.
- Enhanced code organization by consolidating credential management functionalities and improving the overall structure of the OpenHuman module.
* Enhance Rust core RPC structure and streamline helper functions
- Introduced a dedicated `rpc.rs` file for each domain in the Rust core to manage JSON-RPC and CLI behavior, improving code organization and clarity.
- Refactored helper functions to utilize `rpc_invocation_from_outcome` for consistent handling of RPC responses across various modules.
- Removed unused authentication and credential management functions from `helpers.rs`, consolidating relevant logic into the new RPC structure.
- Updated dispatch logic in multiple modules to leverage the new RPC functions, enhancing maintainability and reducing code duplication.
* Enhance Rust core RPC structure and streamline helper functions
- Introduced a dedicated `rpc.rs` file for each domain in the Rust core to manage JSON-RPC and CLI behavior, improving code organization and clarity.
- Refactored helper functions to utilize `rpc_invocation_from_outcome` for consistent handling of RPC responses across various modules.
- Removed unused authentication and credential management functions from `helpers.rs`, consolidating relevant logic into the new RPC structure.
- Updated dispatch logic in multiple modules to leverage the new RPC functions, enhancing maintainability and reducing code duplication.
* Refactor OpenHuman configuration loading and enhance onboarding RPC
- Replaced the `load_openhuman_config` function with a new `load_config_with_timeout` method to improve timeout handling during configuration loading.
- Consolidated configuration loading logic across various modules, reducing redundancy and enhancing maintainability.
- Introduced new RPC functions for applying settings related to models, memory, screen intelligence, gateway, tunnel, runtime, and browser, streamlining the update process.
- Added onboarding helpers in a new `onboard` module, including a JSON-RPC controller for model refresh operations, improving onboarding flow management.
* Refactor CLI and configuration management in OpenHuman
- Consolidated CLI-related functionality by introducing new modules for settings and credentials management, enhancing code organization.
- Removed redundant functions and streamlined the configuration loading process, improving maintainability.
- Added new CLI helpers for screenshot tools and workspace initialization, facilitating better user experience and onboarding.
- Enhanced JSON-RPC responses to be more compatible with CLI requirements, ensuring consistent output across various commands.
* Remove gateway settings and related functionality from OpenHuman
- Eliminated the GatewaySettingsUpdate interface and associated functions from the codebase, streamlining configuration management.
- Removed references to gateway settings in the CLI and configuration modules, enhancing clarity and maintainability.
- Deleted the gateway module and its related components, including rate limiting and client handling, to simplify the architecture.
- Updated Cargo.toml and Cargo.lock to reflect the removal of dependencies related to gateway functionality.
* Update documentation and improve clarity in OpenHuman
- Revised comments in the `mod.rs`, `traits.rs`, and `pairing.rs` files to enhance clarity and accuracy.
- Updated descriptions related to security policy, long-running processes, and pairing functionality for better understanding.
* Refactor loading prop in TauriCommandsPanel for cleaner code
- Simplified the loading prop assignment in the TauriCommandsPanel component by removing unnecessary line breaks, enhancing readability and maintainability.
* Add OpenSSL dependency and implement OAuth authentication features
- Added OpenSSL as a dependency in `Cargo.toml` to support cryptographic operations.
- Introduced new OAuth-related structures and parameters in `types.rs` for handling authentication flows.
- Implemented OAuth connection and integration token fetching in `auth_socket.rs`, enhancing the authentication capabilities of the OpenHuman module.
- Created new modules for managing authentication profiles and responses, improving the organization of authentication-related code.
- Removed deprecated `anthropic_token` and `openai_oauth` modules to streamline credential management.
- Updated `Cargo.lock` to reflect the addition of the OpenSSL dependency.
* Refactor OpenHuman module and update dependencies
- Added OpenHuman integration entry in the registry for improved backend inference handling.
- Updated various files to enhance code clarity and organization, including adjustments to OAuth client methods and integration tests.
- Refactored import statements and removed unnecessary line breaks for better readability.
- Updated `Cargo.lock` to reflect changes in dependencies and ensure consistency across the project.
* Implement desktop host features and refactor runtime handling
- Introduced new modules for memory management, socket handling, and command definitions to support desktop host functionality.
- Refactored QuickJS runtime initialization to log errors when the engine is not linked, improving clarity on runtime status.
- Added placeholder commands for chat and model interactions, indicating unavailability in the desktop build while maintaining structure for future integration.
- Enhanced organization of the codebase by creating dedicated files for runtime and utility functions, streamlining the development process.
- Updated documentation to reflect new modules and their purposes, ensuring better understanding for future contributors.
* Add CLI banner and print function to enhance user experience
- Introduced a new CLI banner with branding and GitHub link for user engagement.
- Implemented a `print_cli_banner` function to display the banner when running the CLI, improving visibility and user interaction.
- Updated the CLI entry point to call the new banner function, ensuring it appears at startup.
* Add API integration and update dependencies
- Introduced new API modules for handling HTTP requests and WebSocket connections to the TinyHumans backend.
- Added `ureq` dependency for simplified HTTP client functionality, updating `Cargo.toml` and `Cargo.lock` accordingly.
- Implemented configuration and JWT handling in the new `api` module, enhancing session management and API interactions.
- Refactored existing code to utilize the new API helpers, improving code organization and maintainability.
- Updated documentation to reflect new API functionalities and usage guidelines.
* Refactor settings fetching and update dependencies
- Removed the `ureq` dependency and associated functions for fetching settings, streamlining the codebase.
- Updated the `fetch_settings` method to utilize `reqwest` for HTTP requests, enhancing consistency and reliability in API interactions.
- Adjusted the `Cargo.toml` to reflect the removal of `ureq`, ensuring dependencies are up to date.
* Update `ureq` dependency to version 3.3.0 in `Cargo.lock`
- Removed the specific version constraint for `ureq`, allowing for more flexibility in dependency resolution.
- Updated the `Cargo.lock` to reflect the new version of `ureq`, ensuring compatibility with recent changes in the codebase.
* Enhance JSON-RPC logging and CLI initialization
- Introduced a new `rpc_log` module for structured logging of JSON-RPC requests and responses, including redaction of sensitive parameters.
- Updated `execute_core_cli` to initialize logging with a default level and timestamp format.
- Enhanced logging in `rpc_handler` and `dispatch` functions to provide detailed insights into method calls and their execution times.
- Improved error handling logging to capture method failures with context, aiding in debugging and monitoring.
* Refactor HTTP server setup and add integration tests
- Introduced a new `build_core_http_router` function to encapsulate the HTTP routing logic, improving code organization and readability.
- Updated the `run_server` function to utilize the new router function, streamlining server initialization.
- Added comprehensive integration tests for the JSON-RPC API, ensuring robust functionality and error handling in real-world scenarios.
* Enhance OpenHuman backend integration and refactor provider handling
- Added support for the OpenHuman backend in the TauriCommandsPanel, including default configurations and validation for API keys.
- Introduced a new REPL command in the CLI for interactive RPC communication, allowing for dynamic mode switching and message handling.
- Refactored provider creation logic to streamline the integration of the OpenHuman backend, removing deprecated provider overrides and ensuring consistent usage across the codebase.
- Updated various components to improve error handling and user feedback related to provider selection and API interactions.
* Refactor provider handling and update default model settings
- Removed provider override states from the AgentChatPanel and TauriCommandsPanel components, simplifying state management.
- Updated local storage handling to exclude provider overrides, ensuring cleaner data storage.
- Changed default model settings across various components and backend configurations to use "neocortex-mk1" as the new default model.
- Enhanced error handling and validation logic in the TauriCommandsPanel, focusing on model and temperature settings.
- Streamlined integration tests and removed deprecated provider validation logic to improve code clarity and maintainability.
* Refactor code for improved readability and consistency
- Adjusted formatting in several files to enhance code clarity, including consistent parameter passing and alignment.
- Simplified match statement syntax in the `run_models` function for better readability.
- Streamlined assertions in tests to maintain consistency in error handling checks.
- Updated default model name handling in the `AgentBuilder` for cleaner initialization.
* Refactor API URL handling and enhance error reporting
- Updated the `effective_api_url` function to improve clarity in resolving the API base URL, incorporating environment variable checks.
- Enhanced diagnostics in the configuration check to provide clearer messages regarding the API URL status.
- Introduced new error formatting functions to improve the clarity of error messages related to API transport issues.
- Refactored error handling in the OpenAiCompatibleProvider to utilize the new error formatting, ensuring consistent and informative error reporting.
* Refactor API client initialization for consistency
- Updated the instantiation of `BackendOAuthClient` to consistently pass the API URL by reference across multiple functions.
- Simplified the match statement in the `run_models_refresh` function for improved readability.
* Enhance REPL command handling and add fallback mechanisms
- Improved error handling in the REPL command processing, providing clearer feedback for command execution failures.
- Introduced a fallback mechanism for the `agent_chat` RPC call, allowing for graceful degradation to a simpler chat method or a direct backend curl transport if the primary call fails.
- Added a new `backend_chat_via_curl` function to handle chat requests using curl as a last resort, ensuring continued functionality in case of RPC issues.
- Updated the `agent_chat_simple` function to support model overrides and temperature settings, enhancing flexibility in chat interactions.
* Update default Ollama model settings for consistency
- Changed the default Ollama model and vision model to "gemma3:4b-it-qat" for improved alignment across configurations.
- Ensured consistent model naming to enhance clarity in model usage within the local AI module.
* Implement login token consumption and enhance error handling
- Added functionality to consume login tokens via a new API endpoint, returning a JWT for authenticated sessions.
- Improved error handling in the Conversations component, introducing a fallback mechanism for chat interactions when the primary method is unavailable.
- Updated UserProvider to restore session tokens automatically, enhancing user experience during authentication.
- Refactored thread API to support the new login token consumption logic, ensuring seamless integration with the backend.
* Update HTTP client configuration to use Rustls TLS
- Replaced the HTTP/1.1 only setting with Rustls TLS in the OpenAiCompatibleProvider's client builder for enhanced security.
- Ensured consistent application of the new TLS setting across multiple client instances.
* Add Local AI command support and enhance error handling
- Introduced a new `LocalAi` command in the CLI for managing local AI runtime operations, including status checks, asset downloads, and prompt handling.
- Added detailed argument structures for various local AI functionalities, improving command usability.
- Enhanced error reporting in the `LocalAiService` by including response details in error messages for better debugging and user feedback.
- Refactored existing error handling to provide clearer context on failures during API interactions.
* Add local AI module with Ollama integration and model management
- Introduced a new local AI module that includes functionality for automatic installation of the Ollama runtime across different operating systems (Windows, macOS, Linux).
- Implemented model ID resolution and management, providing default settings for various AI models and ensuring compatibility with user configurations.
- Added HTTP API structures and request handling for Ollama, enabling interaction with the local AI service for generating responses and managing assets.
- Developed utility functions for parsing model outputs and managing workspace paths, enhancing the overall structure and usability of the local AI service.
- Established a comprehensive service layer for managing local AI operations, including status tracking and error handling for improved user experience.
* Refactor local AI service structure and enhance asset management
- Simplified the local AI module by reorganizing the service structure, introducing new modules for model IDs, paths, and asset management.
- Added comprehensive asset status tracking for various AI models, including chat, vision, embedding, STT, and TTS, with improved error handling.
- Implemented methods for downloading models and assets, ensuring better management of local AI resources.
- Updated visibility of service methods to enhance encapsulation and maintainability within the local AI service.
* Enhance local AI module with new download progress tracking and unit tests
- Added new structures for tracking download progress of various AI models, including detailed status and metrics.
- Implemented unit tests for model ID resolution, parsing suggestions, and asset path resolution to ensure robust functionality.
- Refactored service methods to improve encapsulation and maintainability, enhancing the overall structure of the local AI service.
- Updated existing tests to cover new functionalities and ensure consistent behavior across the module.
* Implement new local AI download functionalities and refactor model management
- Added support for downloading all local AI assets and tracking download progress, enhancing user experience and resource management.
- Introduced new RPC methods for fetching download progress and managing asset states, improving the overall functionality of the local AI module.
- Refactored existing model management code to utilize the new model catalog, ensuring better organization and maintainability.
- Updated relevant tests to cover new functionalities and ensure consistent behavior across the local AI service.
* Add new interfaces and functions for local AI download progress tracking
- Introduced `LocalAiDownloadProgressItem` and `LocalAiDownloadsProgress` interfaces to structure download progress data for various AI models.
- Implemented `openhumanLocalAiDownloadAllAssets` and `openhumanLocalAiDownloadsProgress` functions to facilitate downloading all assets and tracking their progress.
- Enhanced error handling for Tauri environment checks in new functions, ensuring robust operation within the local AI module.
* Refactor agent loop structure and introduce modular components
- Deleted the `loop_.rs` file and reorganized the agent loop into multiple modules for better maintainability and clarity.
- Introduced new files for handling credentials, history management, tool instructions, memory context, and parsing logic.
- Implemented functions for scrubbing sensitive credentials, managing conversation history, and building tool instructions.
- Enhanced the overall structure of the agent loop to facilitate easier testing and future development.
* Refactor authentication structure and migrate to credentials module
- Moved authentication-related functionality from `auth_profiles` to a new `credentials` module for better organization and clarity.
- Updated references in the API and core server to reflect the new module structure.
- Introduced new data structures and methods for managing authentication profiles, including session support and response handling.
- Removed the obsolete `auth_profiles` module to streamline the codebase and enhance maintainability.
* Add screen intelligence module with capture and context management
- Introduced new modules for screen capture and context management, specifically targeting macOS.
- Implemented functionality to capture screen images and retrieve foreground application context.
- Added data structures for managing application context and window bounds.
- Established limits for screenshot sizes and context character counts to ensure efficient resource management.
- Enhanced helper functions for input action validation and vision summary processing.
- Set up a modular structure for better maintainability and future enhancements.
* Refactor screen intelligence module and remove obsolete components
- Deleted unused files related to screen intelligence, including context and permissions management, to streamline the codebase.
- Refactored the capture functionality to improve organization and maintainability.
- Updated function signatures for better clarity and consistency.
- Enhanced the overall structure of the screen intelligence module for future development and testing.
* Enhance autocomplete CLI functionality and refactor related code
- Added new options for the autocomplete command in the CLI, allowing users to run the autocomplete loop in the current process or spawn a detached process.
- Introduced `AutocompleteStartCliOptions` struct to encapsulate the new command-line arguments.
- Refactored the `autocomplete_start_cli` function to handle the new options and improve process management for the autocomplete service.
- Updated documentation in `CLAUDE.md` to clarify the separation of concerns between routing and controller logic in the codebase.
* Enhance autocomplete error handling and improve focused text context retrieval
- Added a new function to identify "no text candidate" errors, improving error management in the autocomplete engine.
- Refactored the `focused_text_context` and `focused_text_context_verbose` functions to enhance clarity and reliability in retrieving application context.
- Updated the return format of the `focused_text_context_verbose` function to use a separator for better data parsing.
- Added a new TODO item for allowing users to select LLM model versions based on their CPU capabilities.
* Remove Docker, Native, and WASM runtime implementations along with related traits and tests
- Deleted the DockerRuntime, NativeRuntime, and WasmRuntime implementations to streamline the codebase.
- Removed associated traits and factory functions for runtime creation.
- Eliminated all related tests to ensure a clean removal of unused components.
- This refactor aims to simplify the runtime management and prepare for future enhancements.
* Add quickjs-runtime feature and introduce runtime module
- Added a new feature flag for `quickjs-runtime` in `Cargo.toml` to enable its usage.
- Created a new `runtime.rs` module to implement `NativeRuntime` and `DockerRuntime` with associated traits for runtime management.
- Updated the `skills` module to reference the correct path for `SkillConfig`.
- Removed the obsolete `skillforge` module from the `openhuman` namespace to streamline the codebase.
- Enhanced the `skills` module with new structures and functions for managing skills, including initialization and loading logic.
* Refactor autocomplete configuration to remove legacy disabled apps
- Updated the default configuration for `AutocompleteConfig` to remove the legacy disabled apps ('terminal' and 'code'), allowing for broader usage of Codex/CLI.
- Introduced a migration function to handle legacy disabled apps during configuration loading, ensuring custom user preferences remain intact.
- This change enhances the flexibility of the autocomplete feature by preventing unnecessary restrictions on application usage.
* Update rquickjs dependencies in Cargo.lock
- Updated the rquickjs and rquickjs-core dependencies to versions 0.11.0 and 0.9.0 respectively, ensuring compatibility with the latest features and fixes.
- Added new entries for rquickjs-sys and its corresponding version 0.9.0 to the dependency list, enhancing the project's runtime capabilities.
- This update improves the overall stability and performance of the application by leveraging the latest improvements in the rquickjs ecosystem.
* Add terminal application detection to autocomplete logic
- Introduced a new function `is_terminal_app` to identify terminal applications based on their names, enhancing the autocomplete feature's context awareness.
- Updated the `focused_text_context_verbose` function to allow terminal applications to bypass text role checks when the input value is not empty, improving user experience in terminal environments.
- This change aims to provide better support for terminal-based applications in the autocomplete system.
* Add terminal input context extraction and noise line detection
- Introduced functions to identify terminal-like buffers and filter out noise lines in terminal input, enhancing the autocomplete engine's context awareness.
- Updated the `focused_text_context` logic to utilize the new terminal context extraction, improving the handling of text in terminal applications.
- Enhanced the `focused_text_context_verbose` function to better retrieve static text values from UI elements, ensuring accurate context representation in terminal environments.
- These changes aim to improve user experience and functionality for terminal-based applications in the autocomplete system.
* Enhance autocomplete engine state management and error handling
- Added new fields `last_escape_down` and `last_overlay_signature` to `EngineState` for improved state tracking.
- Implemented `try_reject_via_escape` method to handle escape key interactions, allowing users to reject suggestions more intuitively.
- Updated error handling to display notifications for different states (ready, accepted, rejected, error) using `show_overflow_badge`.
- Refactored state updates to ensure consistent management of suggestion and phase transitions, enhancing overall user experience in the autocomplete system.
* Implement periodic status logging in autocomplete service
- Added a polling mechanism to log the status of the autocomplete engine at regular intervals.
- Enhanced logging to capture changes in phase, application name, suggestions, and errors, improving visibility during service execution.
- Refactored the `autocomplete_start_cli` function to integrate the new logging functionality, ensuring a more informative user experience while the service is running.
* Refactor memory dispatch logic and remove local memory implementation
- Updated the memory dispatch functions to utilize the new `memory_rpc` module, enhancing the handling of memory operations such as document management and namespace queries.
- Removed the local memory implementation, including database interactions and related functions, to streamline the codebase and improve maintainability.
- Introduced new RPC calls for document operations (put, list, delete) and context queries, ensuring a more efficient and consistent approach to memory management.
- This refactor aims to enhance the overall architecture and performance of the memory handling system.
* Remove macOS-specific overflow badge functionality and related helper functions
- Deleted the `show_overflow_badge` and `escape_applescript_string` functions, which were specific to macOS, to streamline the codebase.
- Refactored the `show_overflow_badge` function to provide a no-op implementation for non-macOS platforms, enhancing cross-platform compatibility.
- This change simplifies the autocomplete module by removing platform-dependent code, improving maintainability and clarity.
* Enhance text application logic in autocomplete module
- Updated the `apply_text_to_focused_field` function to improve interaction with focused UI elements on macOS.
- The new implementation retrieves the current value of the focused element and appends the provided text, ensuring better handling of text input.
- Enhanced error reporting to include stderr output when applying suggestions fails, improving debugging capabilities.
- These changes aim to provide a more robust and user-friendly experience in the autocomplete functionality.
* Refactor Landlock feature configuration for Linux support
- Moved the `landlock` and `rppal` dependencies under a conditional target configuration for Linux in both `Cargo.toml` files, ensuring they are only included when building for Linux.
- Updated the `landlock.rs` module to check for both the `sandbox-landlock` feature and the Linux target OS, improving the conditional compilation logic.
- This change enhances cross-platform compatibility and ensures that Landlock functionality is only available on supported systems.
* Update dependencies and enhance Tauri integration
- Updated the Tauri dependency in `Cargo.toml` to include the `tray-icon` feature, enabling system tray support.
- Introduced a new `rust-toolchain.toml` file to pin the Rust version to 1.93.0, ensuring compatibility with the matrix-sdk.
- Modified GitHub workflows to use the specified Rust version from `rust-toolchain.toml` instead of the stable version, improving build consistency.
- Refactored Tauri commands to utilize a new `wrapCommandResult` function for better response handling.
- Added a new `tray` module in `openhuman` for managing system tray functionality, enhancing the desktop experience.
- Updated various command implementations to streamline service management and improve error handling.
* Refactor core process handling and enhance encryption features
- Removed the `openhuman` dependency from `Cargo.lock` and `Cargo.toml`, streamlining the project structure.
- Updated the core process handling to fall back to a child process when in-process execution is unavailable, improving error handling and logging.
- Introduced new encryption commands (`ai_init_encryption`, `ai_encrypt`, `ai_decrypt`) to enhance security features, utilizing AES-GCM for data protection.
- Added a new `tray` module for managing system tray functionality, improving user experience on desktop platforms.
- Refactored various command implementations to improve service management and error handling, ensuring a more robust application architecture.
* Remove unused modules and refactor daemon host configuration
- Deleted the `daemon_host_config`, `memory`, `models`, `openhuman_daemon`, `tray`, `chat`, `conscious_loop`, and `runtime` modules to streamline the codebase.
- Refactored the daemon host configuration logic into the `openhuman` module, consolidating related functionality.
- Updated command implementations to utilize the new configuration methods, ensuring consistent handling of daemon host settings.
- This cleanup enhances maintainability and reduces complexity in the project structure.
* Refactor memory management and update Tauri dependencies
- Removed the `tray-icon` feature from the Tauri dependency in `Cargo.toml` to streamline the configuration.
- Deleted the `core:tray:default` capability from the default capabilities JSON, simplifying the capabilities structure.
- Refactored memory handling in tests to utilize `UnifiedMemory` instead of `SqliteMemory`, enhancing consistency across memory operations.
- Updated memory store, recall, and forget functionalities to support a global namespace, improving memory management and retrieval processes.
- Enhanced error handling and logging in memory operations to provide clearer feedback during execution.
* Remove AI encryption commands and related functionality
- Deleted the `ai_init_encryption`, `ai_encrypt`, and `ai_decrypt` functions to streamline the codebase and remove unused features.
- Updated the command registration in the `run` function to reflect the removal of these encryption commands, enhancing maintainability and reducing complexity.
* Add OAuth integration token handling and channel connection management
- Introduced functions to fetch and encrypt integration tokens using OAuth, enhancing security for token management.
- Updated the channel connections API to support OAuth integration, including listing, connecting, and disconnecting channels.
- Implemented checks for supported channels and authentication modes, improving the robustness of channel connection handling.
- Enhanced error handling for integration token retrieval to ensure required fields are present before proceeding.
* Refactor project structure and update documentation
- Renamed the project from "Outsourced" to "OpenHuman" and revised the project summary to reflect its focus on AI-powered assistance for crypto communities.
- Restructured the repository layout, detailing the purpose of each directory and its contents.
- Updated runtime scope to clarify platform support and Tauri's desktop-only focus.
- Enhanced documentation across various files, including architecture, services, and routing, to improve clarity and usability for contributors.
- Removed outdated sections and streamlined commands for development and production builds, ensuring consistency in the documentation.
* Implement REPL session management and multimodal support
- Introduced a new REPL session management system, allowing for session-specific interactions with agents.
- Added functions for starting, chatting, resetting, and ending REPL sessions, enhancing user experience and control.
- Implemented multimodal message handling, enabling the processing of images alongside text in user messages.
- Updated the project structure to include new modules for identity and multimodal functionalities, improving organization and maintainability.
- Enhanced error handling and logging for session operations, providing clearer feedback during execution.
* Refactor memory store implementation and introduce unified memory management
- Removed the legacy memory store implementation and replaced it with a new unified memory management system.
- Introduced a `MemoryClient` for handling document storage, retrieval, and namespace management.
- Added support for key-value storage and graph data structures within the unified memory framework.
- Enhanced the `UnifiedMemory` struct with methods for document upsertion, querying, and namespace operations.
- Updated the project structure to include new modules for memory types, factories, and traits, improving organization and maintainability.
- Improved error handling and logging across memory operations for clearer feedback during execution.
* Implement QuickJS skill instance management
- Removed the previous QjsSkillInstance implementation and replaced it with a new modular structure.
- Introduced separate modules for event loop management, instance handling, JavaScript handlers, and utility functions.
- Enhanced the event loop to efficiently manage QuickJS runtime tasks, including timer callbacks and message processing.
- Added support for asynchronous tool calls and lifecycle management within the QuickJS context.
- Improved error handling and logging throughout the new implementation for better debugging and user feedback.
- Updated documentation to reflect the new structure and functionality of the QuickJS skill instance.
|
||
|
Steven EnamakelandGitHub
|
b6ec716b7c |
feat(cli): integrate clap_complete for shell command completions (#49)
* feat(daemon): introduce daemon host configuration management - Updated the daemon service to support a new configuration structure for managing tray visibility. - Added functions to load and save daemon host configuration from a JSON file. - Implemented Tauri commands to retrieve and update the daemon host configuration. - Enhanced the service management logic to account for legacy application labels and improve compatibility on macOS. - Refactored executable resolution logic to streamline the process of locating the daemon executable across platforms. * feat(daemon): enhance daemon host configuration with tray visibility settings - Added functionality to load and save daemon host configuration, specifically for managing the visibility of the daemon tray icon. - Implemented UI components in both DaemonHealthPanel and TauriCommandsPanel to toggle the tray visibility setting. - Integrated Tauri commands to retrieve and update the daemon host configuration, improving user control over the daemon's display options. - Enhanced loading states and error handling for better user feedback during configuration updates. * fix(local-ai): update default model IDs for local AI configuration - Changed default model IDs from `qwen2.5:1.5b` and `qwen3-vl:2b` to `gemma3:4b-it-qat` for chat and vision models, ensuring consistency in local AI settings. * feat(core): enhance macOS service management and CLI thread stack size - Added dynamic configuration for thread stack size in the CLI, allowing customization via the `OPENHUMAN_CORE_THREAD_STACK_SIZE` environment variable. - Improved macOS service management by validating the LaunchAgent plist and ensuring it is installed before starting the service. - Enhanced error handling and logging for service loading and plist validation, improving user feedback and reliability. * feat(app): initialize Tauri + React + TypeScript project structure - Added essential project files including package.json, tsconfig.json, and Vite configuration for a Tauri application using React and TypeScript. - Created initial HTML template and CSS styles for the application interface. - Included .gitignore to exclude build artifacts and environment-specific files. - Established basic README documentation to guide setup and development. * feat(cli): refactor command structure for core CLI - Replaced the existing CLI command structure with a new design using `clap` for better organization and extensibility. - Introduced a `CoreCli` struct with subcommands for various operations including server management, health checks, and configuration settings. - Updated command handling to support new subcommands for settings and accessibility operations, enhancing the CLI's functionality. - Modified the core process handling to reflect the new command structure, ensuring compatibility with the updated CLI design. * chore(eslint): add 'app/**' to ignored paths in ESLint configuration - Updated the ESLint configuration to include the 'app/**' directory in the list of ignored paths, ensuring that files in this directory are not linted during the development process. * chore(prettier): add 'app' directory to .prettierignore - Updated the .prettierignore file to include the 'app' directory, preventing formatting checks on files within this path during development. * feat(cli): integrate clap_complete for shell command completions - Added support for generating shell completion scripts using `clap_complete`, enhancing the CLI's usability. - Introduced new subcommands for generating completions and updated command structures to accommodate this feature. - Implemented a new `capture_image_ref` command in the accessibility module for direct image reference capture. - Enhanced the `Tools` command structure to include screenshot functionalities, improving CLI tool management. |