4 Commits

Include renames

Author	SHA1	Message	Date
Steven EnamakelandGitHub	7ad3c73ac3	Refactor UI auth/bootstrap and remove legacy UI runtime layers (#63) ... * Enhance E2E build process and backend URL handling - Updated `e2e-build.sh` to set CI environment variable correctly for compatibility with various CI runners. - Refactored `backendUrl.ts` to support dynamic backend URL resolution from Vite environment variables, improving flexibility in different deployment contexts. * Implement web channel functionality and enhance chat features - Introduced new web channel commands for sending and canceling chat messages, improving user interaction with the chat system. - Added support for server-sent events (SSE) to handle real-time updates for chat interactions, enhancing responsiveness. - Refactored existing code to improve readability and maintainability, including updates to the core HTTP router and JSON-RPC handling. - Implemented comprehensive end-to-end tests for the web channel flow, ensuring robust functionality and user experience. - Enhanced the overall structure of the web channel module, including event publishing and subscription mechanisms for better scalability. * Refactor socket handling to unify communication across environments - Removed Tauri-specific socket handling from various components, streamlining the codebase to use a single Socket.IO client for both web and desktop environments. - Updated the `useIntelligenceSocket` hook to eliminate Tauri checks and directly utilize the socket service for message sending and chat initialization. - Refactored metadata synchronization in Gmail and Notion services to use the unified socket service, enhancing consistency in socket communication. - Improved error handling and logging across socket interactions to provide clearer feedback during connection issues. - Enhanced the Conversations component to manage socket connection status, ensuring a more robust user experience during chat interactions. * Refactor socket service and enhance core URL resolution - Replaced the deprecated `getBackendUrl` function with `resolveCoreSocketBaseUrl` to improve backend URL resolution for socket connections, accommodating both Tauri and non-Tauri environments. - Introduced `coreSocketBaseFromRpcUrl` to streamline the processing of RPC URLs. - Removed the `tauriSocket.ts` file, consolidating socket handling into a unified service for better maintainability and clarity. - Updated the socket connection logging to provide more informative messages during connection attempts. * Add engineioxide and socketioxide packages to Cargo.lock and update Cargo.toml - Introduced new packages: `engineioxide` and `socketioxide`, both at version 0.15.2, enhancing the project's capabilities. - Updated `Cargo.toml` to include `socketioxide` with the "extensions" feature, ensuring proper integration with the existing codebase. - Added dependencies for both packages, improving modularity and functionality across the application. * Refactor Conversations component and streamline chat handling - Removed unused imports and functions related to Notion context and socket handling, simplifying the Conversations component. - Enhanced error handling during chat interactions, ensuring clearer feedback for users. - Updated chatSend function parameters to eliminate unnecessary context, improving the clarity of the API call. - Consolidated logic for managing chat message history and context, enhancing maintainability and readability of the code. * Enhance core RPC client with improved logging and error handling - Introduced debug logging for socket RPC requests and responses, providing better visibility into the communication process. - Enhanced error handling in the core RPC client to log detailed error messages, improving debugging capabilities. - Updated socket service to log inbound events, ensuring comprehensive tracking of socket interactions. - Removed deprecated MCP handlers from the socket service, streamlining the codebase and improving maintainability. * Refactor apiClient and socketService for improved maintainability - Changed the declaration of `_getToken` from `let` to `var` in `apiClient.ts` to enhance variable scoping. - Removed unused imports in `socketService.ts`, streamlining the code and improving readability. * Refactor deep link handling and enhance E2E testing capabilities - Updated the deep link configuration in `lib.rs` to use a more generalized `#[cfg(desktop)]` directive, improving compatibility across desktop platforms. - Enhanced the `triggerDeepLink` function in `deep-link-helpers.ts` to include macOS-specific app activation and launching logic, ensuring better integration with the macOS environment. - Introduced a new `buildBypassJwt` function to generate bypass JWT tokens for E2E testing, improving the flexibility of authentication flows in tests. - Updated E2E tests in `conversations-web-channel-flow.spec.ts` to utilize the new `triggerAuthDeepLinkBypass` function, enhancing the testing of authentication scenarios. * Enhance deep link handling and E2E test configuration - Updated `triggerAuthDeepLink` in `deep-link-helpers.ts` to support environment-based bypass tokens, improving flexibility in authentication flows during E2E tests. - Modified the `serve_on_ephemeral` function call in `json_rpc_e2e.rs` to disable the core HTTP router's default behavior, enhancing test isolation and control over the testing environment. * Refactor deep link handling and enhance E2E test utilities - Updated `authFlow.e2e.test.tsx` to utilize `window.__simulateDeepLink` for simulating deep links, improving test accuracy and alignment with real-world scenarios. - Modified `lib.rs` to restrict deep link registration to Windows and Linux platforms, clarifying platform-specific behavior. - Enhanced `deep-link-helpers.ts` with a new function to simulate deep links in the WebView, providing a fallback mechanism for E2E tests. - Updated `conversations-web-channel-flow.spec.ts` to reflect changes in deep link triggering, improving logging and test clarity. * Update dependencies in Cargo.lock and Cargo.toml for improved project stability - Removed several unused dependencies from `Cargo.lock` and `Cargo.toml`, including `aes-gcm`, `argon2`, and `async-imap`, streamlining the project and reducing potential security vulnerabilities. - Updated existing dependencies to their latest versions, ensuring compatibility and leveraging improvements in performance and security. - Simplified the dependency structure by consolidating features and removing unnecessary comments, enhancing clarity and maintainability of the configuration files. * Refactor App component and remove unused providers - Removed `AIProvider` and `SkillProvider` from the `App` component, streamlining the component structure and improving readability. - Updated the `UserProvider` to focus solely on bootstrapping the authentication token, enhancing its clarity and purpose. - Adjusted the layout within the `App` component to maintain functionality without the removed providers, ensuring a smooth user experience. * Remove deprecated AI components and types - Deleted the `index.ts`, `loader.ts`, `types.ts`, and related test files from the AI module, streamlining the codebase by removing unused and outdated components. - Eliminated the `default-constitution.md` and associated constitution files, which were no longer relevant to the current architecture. - This cleanup enhances maintainability and reduces complexity within the AI system. * Refactor user data fetching logic and remove legacy tools cache watcher - Enhanced the `useUser` hook to prevent infinite retry loops by implementing a token check with a reference to track the last auto-fetch token. - Removed the legacy file watcher for `TOOLS.md`, transitioning to a core RPC and socket event-based refresh mechanism for tool/config updates. - Updated test state structure to include `isAuthBootstrapComplete` and `channelConnections`, improving test coverage and state management. * Refactor channel module structure and add new providers - Consolidated channel modules under a new `providers` directory, improving organization and clarity. - Introduced new channel providers for DingTalk, Discord, Email, iMessage, IRC, and Lark, expanding the messaging capabilities of the application. - Updated the `mod.rs` file to reflect the new structure and ensure proper module exports, enhancing maintainability and ease of use. * refactor(ui): remove legacy providers/lib logic and stabilize auth bootstrap * chore: apply pre-push auto-fixes	2026-03-29 20:22:38 -07:00
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.	2026-03-29 18:14:13 -07:00
Steven EnamakelandGitHub	c1a3ae1cfe	Refactor controller registration into domain schemas and generic registry (#53) ... * Refactor core server helpers and enhance REPL dotenv loading - Removed unused functions for extracting namespaces and filtering documents by namespace from `helpers.rs`, streamlining the codebase. - Introduced dotenv loading functionality in `repl.rs`, allowing for environment variable management from a specified `.env` file. - Added utility functions for parsing dotenv values and resolving the dotenv file path, improving configuration handling in the REPL. - Enhanced logging for dotenv loading to provide better visibility into the process and any issues encountered. * Add AI RPC module and enhance core server dispatch functionality - Introduced a new `rpc` module within the `ai` namespace to handle various AI-related commands, including memory file operations and session management. - Updated the core server's dispatch logic to integrate the new AI RPC functionality, improving modularity and maintainability. - Removed outdated memory dispatch implementation and streamlined the overall dispatch structure for better performance and clarity. - Enhanced error handling and logging throughout the new functionalities to improve maintainability and user feedback. * Refactor project structure and enhance RPC functionality - Introduced a new `rpc` module to streamline JSON-RPC handling across various domains, improving code organization and maintainability. - Updated the core server and API modules to utilize the new `rpc` structure, enhancing modularity and reducing code duplication. - Added new models for authentication and socket management, improving the overall functionality of the API. - Removed outdated references to the previous `openhuman` RPC structure, ensuring a cleaner and more efficient codebase. * Update architecture documentation and refactor AI prompt paths - Updated references in architecture documentation to reflect the new directory structure for AI prompts, changing paths from `src/ai/prompts` to `src/openhuman/agent/prompts`. - Enhanced clarity in command documentation by aligning AI-related commands with the updated prompt paths. - Removed obsolete AI module and streamlined memory management references to improve code organization and maintainability. - Introduced new markdown files for agent prompts, establishing a foundation for OpenHuman's AI capabilities. * Update AI prompt paths and configuration references - Changed all references from `src/ai/prompts` to `src/openhuman/agent/prompts` in documentation and code files to reflect the new directory structure. - Updated Tauri configuration to include the new resource paths for AI prompts, ensuring proper access and functionality. - Enhanced the AI configuration commands to align with the updated paths, improving clarity and maintainability across the project. * Enhance core structure and introduce new RPC functionality - Added a new `core` module to centralize shared schemas and contracts for controllers, improving code organization and maintainability. - Introduced `jsonrpc` and `cli` modules within the `core` structure to handle JSON-RPC requests and command-line interactions, enhancing modularity. - Defined a `ControllerSchema` for transport-agnostic function contracts, allowing for consistent handling across RPC and CLI layers. - Established a new `all` module to manage registered controllers and their schemas, streamlining the invocation process. - Updated documentation in `CLAUDE.md` to reflect new controller schema contracts and module organization, improving clarity for developers. * Refactor core server structure and enhance RPC functionality - Removed the `core_server` module and integrated its functionalities into the `core` module, improving code organization and maintainability. - Introduced a new `dispatch` module to handle RPC requests, streamlining the invocation process for various commands. - Updated the CLI to utilize the new core structure, enhancing command handling and modularity. - Added comprehensive logging for RPC interactions, improving visibility and debugging capabilities. - Enhanced error handling across the core server, ensuring consistent feedback for users and developers. * Refactor CLI command handling and enhance JSON-RPC integration - Consolidated CLI command structure by removing the `CoreCli` and directly implementing command functions for `run`, `call`, and `namespace`. - Improved argument parsing for server commands, including port specification and help options, enhancing user experience. - Streamlined the invocation of JSON-RPC methods, ensuring consistent error handling and response formatting across commands. - Introduced a new `run_namespace_command` function to manage namespace-specific operations, improving modularity and clarity in command execution. * Refactor SkillsPanel and TauriCommandsPanel for improved integration handling - Removed unused integration-related functions and state management from SkillsPanel, simplifying the component's logic. - Updated TauriCommandsPanel to eliminate integration name input and associated commands, streamlining the user interface. - Introduced a new local AI memory management module to handle session and memory operations, enhancing overall functionality. - Refactored core RPC client to integrate local AI method dispatching, improving command handling consistency across the application. - Cleaned up tauriCommands utility functions to align with the new command structure, enhancing maintainability. * Refactor TauriCommandsPanel to streamline command handling - Removed the `openhumanModelsRefresh` function and replaced its usage with `openhumanDoctorReport`, simplifying the command logic. - Eliminated unused model refresh buttons from the UI, enhancing the user interface and reducing clutter. - Updated related utility functions in `tauriCommands.ts` to reflect the removal of model refresh functionality, improving maintainability. * Refactor JSON-RPC server integration and remove legacy server module - Updated the CLI to invoke the JSON-RPC server directly, enhancing command execution flow. - Introduced a new HTTP router in the `jsonrpc` module, consolidating route handling for health checks and RPC requests. - Removed the deprecated `server` module, streamlining the codebase and improving maintainability. - Adjusted tests to reflect the new routing structure, ensuring continued functionality and integration. * Remove submodule and update CLAUDE.md documentation - Deleted the `.gitmodules` file and removed the `skills` submodule, simplifying the project structure. - Updated the description in `CLAUDE.md` to reflect a broader focus on community assistance rather than just crypto, enhancing clarity. - Added sections on coding philosophy and controller migration checklist to improve developer guidance and maintainability. * Refactor controller registration and enhance schema management - Introduced a centralized registry for registered controllers, improving the organization and validation of controller schemas. - Updated the `all_registered_controllers` and `all_controller_schemas` functions across various modules to streamline controller management. - Added comprehensive validation for controller registration to ensure consistency and prevent duplicate entries. - Enhanced the CLI and JSON-RPC integration to utilize the new registry structure, improving command handling and modularity. - Updated documentation in `CLAUDE.md` to reflect changes in the skills registry and controller management processes, enhancing clarity for contributors. * Enhance autocomplete, config, and credentials modules with new schemas and controller registrations - Added support for autocomplete, config, and credentials functionalities by introducing new schemas and registered controllers. - Updated the `build_registered_controllers` and `build_declared_controller_schemas` functions to include new entries for autocomplete, config, and credentials. - Implemented new JSON-RPC tests for autocomplete and config methods, ensuring proper validation and error handling. - Refactored CLI tests to include checks for new commands related to autocomplete and configuration management, improving test coverage and reliability. - Introduced new modules for schemas in autocomplete, config, and credentials, enhancing code organization and maintainability. * Add local AI and migration modules with schemas and controller registrations - Introduced local AI and migration functionalities by adding new schemas and registered controllers. - Updated the `build_registered_controllers` and `build_declared_controller_schemas` functions to include entries for local AI and migration. - Implemented JSON-RPC tests for local AI and migration methods, ensuring proper validation and error handling. - Enhanced CLI tests to verify new commands related to local AI and migration, improving test coverage and reliability. - Organized code by creating dedicated modules for schemas in local AI and migration, enhancing maintainability. * Refactor controller schemas for config and auth modules - Updated controller schemas for config and auth functionalities, aligning namespaces and function names for consistency. - Changed function names in the JSON-RPC tests to reflect the new schema structure, ensuring proper invocation. - Enhanced CLI tests to verify updated commands related to config and auth, improving test coverage and reliability. - Organized code by consolidating related functionalities under appropriate namespaces, enhancing maintainability. * Add agent and screen intelligence modules with schemas and controller registrations - Introduced agent and screen intelligence functionalities by adding new schemas and registered controllers. - Updated the `build_registered_controllers` and `build_declared_controller_schemas` functions to include entries for agent and screen intelligence. - Created dedicated modules for schemas in agent, screen intelligence, skills, tools, tray, and workspace, enhancing code organization and maintainability. - Implemented initial controller schemas for agent and screen intelligence, providing a foundation for future functionality. - Enhanced the overall structure of the core module to accommodate new integrations, improving modularity and clarity. * Enhance autocomplete and namespace descriptions in core modules - Added a new function `namespace_description` to provide descriptions for various namespaces, improving user guidance in CLI commands. - Updated the CLI help output to include namespace descriptions, enhancing clarity for users. - Introduced a new `core` module for autocomplete functionalities, including various operations and structures related to inline autocomplete. - Refactored the `autocomplete` module to improve organization and maintainability, consolidating related functionalities under appropriate namespaces. - Implemented initial JSON-RPC operations for autocomplete, ensuring a robust interface for managing autocomplete features. * Refactor and clean up code across multiple modules - Removed unnecessary whitespace in `TauriCommandsPanel.tsx`, improving code readability. - Cleaned up imports and reorganized code structure in `localCoreAiMemory.ts`, enhancing maintainability. - Streamlined module imports in `mod.rs` files across various directories, ensuring consistency and clarity. - Deleted the obsolete `rpc.rs` file in the `cron` module, consolidating functionality and reducing clutter. - Updated function definitions in `ops.rs` to improve formatting and readability, enhancing overall code quality. * Refactor session management and enhance module organization - Changed `sessionIndex` from a mutable variable to a constant in `localCoreAiMemory.ts`, improving code clarity and immutability. - Introduced new `ops.rs` files in the `approval`, `providers`, `skills`, and `quickjs_libs` modules, consolidating related functionalities and enhancing code organization. - Streamlined module imports in `mod.rs` files across various directories, ensuring consistency and clarity in module structure. - Removed obsolete code and unnecessary comments, improving overall code readability and maintainability. * Refactor configuration schema organization and module structure - Moved the configuration schema definitions from `mod.rs` to a new `types.rs` file, enhancing modularity and clarity. - Updated module imports across various files to reflect the new structure, ensuring consistency in the codebase. - Cleaned up obsolete code and comments, improving overall readability and maintainability. * Remove obsolete configuration schema file and its associated modules - Deleted the `types.rs` file from the configuration schema, consolidating the codebase and removing unused components. - This change enhances maintainability by eliminating redundant code and streamlining the overall structure of the configuration management. * Fix config schema module exports * Add configuration schema types and enhance module exports - Introduced a new `types.rs` file to define the top-level configuration structure for `config.toml`, improving modularity and clarity. - Updated `mod.rs` to re-export all public types and configurations, ensuring a streamlined interface for the configuration schema. - Enhanced the organization of configuration components, making it easier to manage and extend in the future. * Update import path for AuthProfile and AuthProfileKind in tests module - Changed the import statement for `AuthProfile` and `AuthProfileKind` to use the correct path, ensuring proper module resolution and consistency in the codebase. * Refactor import statements in test files for consistency - Cleaned up import statements across multiple test files by removing unnecessary components and ensuring uniformity in module imports. - This change enhances code readability and maintainability by streamlining the import structure. * Add agent chat and REPL session handling with schemas - Introduced new schemas for agent chat and REPL session management, enhancing the functionality of the agent module. - Implemented handlers for chat and REPL session operations, allowing for more interactive and persistent user sessions. - Updated the memory store to include category handling for memory entries, improving data organization and retrieval. - Refactored memory query methods to support ranked results and category storage, enhancing the memory management capabilities. - Improved error handling in memory recall tools to ensure non-empty parameters, increasing robustness and user feedback. * Refactor JSON-RPC method names for consistency and clarity - Updated JSON-RPC method names in tests to follow a consistent naming convention, improving readability and maintainability. - Adjusted parameter names in the JSON payload to align with the updated method names, ensuring proper functionality and clarity in the API interactions. - Enhanced overall code organization by streamlining method calls in the test suite.	2026-03-29 15:59:34 -07:00
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.	2026-03-29 10:30:18 -07:00