* ci(release): bake Sentry DSN into shipped tauri bundle
Released builds weren't reporting anything to Sentry. Root cause: the
tauri.conf.json `beforeBuildCommand` re-runs `vite build` inside
`cargo tauri build`. The prior `yarn build` step set `VITE_SENTRY_DSN`
for its own run, but the tauri step did not — so the rebuild produced
a DSN-less `dist/` that overwrote the good one, and the shipped web UI
initialized Sentry with an empty DSN (`initSentry` returns early when
`!SENTRY_DSN`).
Fix:
- `release.yml` / `build-desktop` — declare `VITE_SENTRY_DSN` and
`VITE_DEBUG` on the tauri-build step so the `beforeBuildCommand`
rebuild bakes them into the final bundle.
- `release-packages.yml` / `build-cli-linux-arm64` — guard against a
missing `vars.OPENHUMAN_SENTRY_DSN` so the Linux arm64 CLI tarball
cannot ship without error reporting baked in via `option_env!`.
The core sidecar's `option_env!("OPENHUMAN_SENTRY_DSN")` already gets
the value from the dedicated "Build sidecar core binary" step; the
tauri shell doesn't rebuild it (separate crate, not a workspace dep),
so the baked DSN survives into the bundled installer.
* feat(observability): Sentry release tracking + source maps (#405)
Tags every Sentry event with a canonical release identifier shared by
the frontend and Rust core, uploads source maps so stack traces are
symbolicated in the dashboard, and adds a CLI probe for repeatable
verification of any future release.
Release identifier
openhuman@<semver>[+<short_git_sha>]
- Frontend (`app/src/utils/config.ts::SENTRY_RELEASE`) builds the tag
from `VITE_BUILD_SHA`.
- Core sidecar (`src/main.rs::build_release_tag`) builds the same tag
from `option_env!("OPENHUMAN_BUILD_SHA")`, so events from both
surfaces group under one release. Cargo's fingerprint already tracks
`option_env!` changes.
Environment separation
- Frontend: new `APP_ENVIRONMENT` export (`development` | `staging` |
`production`) derived from `VITE_OPENHUMAN_APP_ENV`, passed to
`Sentry.init`.
- Core: `resolve_environment` honors `OPENHUMAN_APP_ENV` at runtime,
falling back to `debug_assertions` detection.
Source-map upload
- `@sentry/vite-plugin` added as an app devDependency.
- `vite.config.ts` emits source maps unconditionally and registers the
plugin only when `SENTRY_AUTH_TOKEN` is present, so local dev skips
silently. The plugin uploads `dist/**/*.js{,.map}` under the
canonical release name and then deletes the on-disk `.map` files so
they never ship to end users.
CI wiring (`release.yml` + `release-packages.yml`)
- `Build frontend` and `Build and package Tauri app` both receive
`VITE_BUILD_SHA`, `SENTRY_RELEASE`, `SENTRY_AUTH_TOKEN`, `SENTRY_ORG`,
`SENTRY_PROJECT_FRONTEND`. The tauri step needs the same env because
its `beforeBuildCommand` re-runs `vite build`.
- `Build sidecar core binary` receives `OPENHUMAN_BUILD_SHA` so
`option_env!` bakes the short SHA into the release tag.
- `build-cli-linux-arm64` mirrors `OPENHUMAN_BUILD_SHA` and
`OPENHUMAN_APP_ENV` for the arm64 CLI tarball.
Verification support
- New `openhuman sentry-test` CLI subcommand captures an `Error`-level
event against the currently-initialized client, flushes, and prints
the event UUID. Optional `--panic` flag exercises the panic
integration. Requires a DSN resolvable at runtime or baked in at
compile time; exits non-zero otherwise so misconfiguration is loud.
- `src/main.rs` now loads `.env` before `sentry::init`, so a DSN
defined only in the repo-local dotenv file (common dev case) is
honored by the startup-time Sentry client.
Docs
- `docs/sentry.md` covers the release identifier, environment table,
source-map pipeline, required CI variables, and a verification
runbook with troubleshooting tips.
- `.env.example` + `app/.env.example` document the new build-time vars.
* Enhance documentation and structure across core modules
- Added comprehensive module-level documentation for `lib.rs`, `main.rs`, `cli.rs`, `jsonrpc.rs`, `mod.rs`, `config.rs`, and `skills.rs`, detailing their functionalities and responsibilities within the OpenHuman platform.
- Improved function-level documentation to clarify arguments, return types, and error handling for key functions such as `run_core_from_args`, `rpc_handler`, and `run_from_cli_args`.
- Enhanced comments throughout the code to improve readability and maintainability, ensuring a clearer understanding of the codebase for future development.
* Enhance documentation for RuntimeEngine and SkillRegistry
- Improved struct and function-level documentation in `qjs_engine.rs` to clarify the lifecycle management of JavaScript-based skills, including skill discovery, startup, and shutdown processes.
- Updated comments in `skill_registry.rs` to provide clearer descriptions of the registry's role in managing active skills and their communication channels.
- Added detailed explanations for key methods, enhancing understanding of their functionality and usage within the OpenHuman platform.
* Enhance documentation across skill modules
- Improved module-level and struct-level documentation in `manifest.rs`, `ops.rs`, `socket_manager.rs`, and `types.rs` to clarify the purpose and functionality of various components within the skills system.
- Added detailed comments for key structs and functions, including `SkillSetup`, `Skill`, and `SocketManager`, enhancing understanding of their roles in skill management and communication.
- Updated descriptions for enums and message types to provide clearer context for their usage in the skill lifecycle and internal messaging.
* Enhance documentation across skills modules
- Added comprehensive module-level documentation for `registry_ops.rs`, `registry_types.rs`, `schemas.rs`, and `qjs_skill_instance` modules, detailing their functionalities and responsibilities within the OpenHuman skills system.
- Improved function-level comments to clarify the purpose and usage of key functions, including `registry_fetch`, `registry_search`, and `skill_install`.
- Enhanced descriptions for structs and enums, providing clearer context for their roles in skill management and execution.
- Updated comments throughout the code to improve readability and maintainability, ensuring a clearer understanding of the codebase for future development.
* Enhance documentation for QuickJS and IndexedDB modules
- Improved module-level documentation in `quickjs_libs/mod.rs` to clarify the purpose and functionality of the QuickJS runtime support.
- Enhanced comments in `storage.rs` to provide detailed descriptions of the IndexedDB storage layer, including its features and compatibility with the browser's IndexedDB API.
- Updated function-level comments to improve clarity on database connection management and object store operations, ensuring better understanding for future development.
* Enhance documentation across memory modules
- Added comprehensive module-level documentation for `mod.rs`, `ops.rs`, `rpc_models.rs`, `schemas.rs`, and `traits.rs`, detailing their functionalities within the OpenHuman memory system.
- Improved function-level comments to clarify the purpose and usage of key functions, enhancing understanding of memory operations, RPC handling, and data structures.
- Updated comments throughout the code to improve readability and maintainability, ensuring a clearer understanding of the memory system for future development.
* Enhance documentation for memory modules
- Updated module-level documentation in `chunker.rs`, `embeddings.rs`, and `relex.rs` to provide clear descriptions of their functionalities within the OpenHuman memory system.
- Improved function-level comments to clarify the purpose and usage of key functions, enhancing understanding of markdown chunking, embedding providers, and relation extraction processes.
- Added detailed explanations for structs and enums, ensuring better context for their roles in memory operations and data handling.
* Enhance documentation across memory modules
- Updated module-level documentation in `ingestion_queue.rs`, `ingestion.rs`, `response_cache.rs`, `client.rs`, and `mod.rs` to provide clearer descriptions of their functionalities within the OpenHuman memory system.
- Improved function-level comments to clarify the purpose and usage of key functions, enhancing understanding of document ingestion, caching mechanisms, and memory client interactions.
- Added detailed explanations for structs and enums, ensuring better context for their roles in memory operations and data handling.
* Enhance documentation for memory store modules
- Added comprehensive module-level documentation for `factories.rs` and `memory_trait.rs`, detailing their functionalities within the OpenHuman memory system.
- Improved function-level comments to clarify the purpose and usage of key functions, enhancing understanding of memory instance creation and management.
- Included detailed explanations for the `UnifiedMemory` implementation, ensuring better context for its role as a generic memory backend.
* Refactor and enhance documentation across various modules
- Removed unnecessary blank lines in `main.rs`, `chunker.rs`, `embeddings.rs`, `ingestion.rs`, `relex.rs`, `rpc_models.rs`, `memory_trait.rs`, `manifest.rs`, `mod.rs`, `ops.rs`, `qjs_engine.rs`, `socket_manager.rs`, and other files to improve code readability.
- Improved comments and documentation in several modules to clarify the purpose and functionality of key components, enhancing overall understanding of the codebase.
- Ensured consistent formatting and organization of comments throughout the code, contributing to better maintainability and clarity for future development.
* fix import
* format
* chore: add CI profile for faster compilation in Cargo.toml files
- Introduced a new `[profile.ci]` section in both root and Tauri Cargo.toml files to optimize build settings for continuous integration.
- Adjusted compilation parameters to prioritize speed over runtime performance, including reduced optimization level and enabled code generation units.
* refactor(tests): update agent test setup to return temporary directory
- Modified the `build_agent_with` function calls in the agent tests to return a temporary directory alongside the agent instance, improving resource management during tests.
- Ensured consistency in test setup across multiple test functions.
* chore: update .gitignore to include fastembed_cache
- Added 'workflow' and '.fastembed_cache' to the .gitignore file to prevent unnecessary files from being tracked in the repository.
* test: enhance dispatch routing tests with panic handling
Updated the `dispatch_routes_memory_doc_ingest` test to use `AssertUnwindSafe` and `catch_unwind` for better handling of potential panics during execution. This ensures that the test verifies route existence even if the handler encounters a panic, improving robustness against shared state issues in concurrent tests.
* ci: speed up builds with rust-cache, sccache, mold linker, and CI profile
- Replace manual Cargo registry cache with Swatinem/rust-cache@v2 (caches
target/ directories for both core and Tauri crates)
- Add mozilla-actions/sccache for cross-branch compilation caching
- Install mold linker on Linux for faster linking
- Use --profile ci for sidecar build (opt-level 1, codegen-units 16)
- Override release profile env vars for Tauri build with CI-tuned settings
- Add --bundles none to CI build (skip unused deb/appimage packaging)
- Restrict push triggers to main branch only (PRs already cover feature
branches, preventing duplicate runs)
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(ci): unset RUSTC_WRAPPER for cargo fmt to avoid sccache errors
The sccache-action sets RUSTC_WRAPPER globally for the job. cargo fmt
invokes rustc through sccache which fails if the GHA cache service is
unavailable. Clear RUSTC_WRAPPER for fmt steps and remove redundant
per-step env overrides (the action already sets them job-wide).
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* refactor: implement Default trait for various structs and enums
- Added Default implementations for ConnectionStatus, AgentBuilder, NativeRuntime, AutocompleteEngine, CliChannel, ActionTracker, SkillStatus, and ExtractionMode to streamline object initialization.
- Simplified condition checks in several places by replacing map_or with is_some_and and is_none_or for better readability and performance.
- Updated various instances of string handling in message sending to remove unnecessary conversions.
This refactor enhances code clarity and consistency across the codebase.
* style: clean up whitespace and improve code formatting
- Removed unnecessary blank lines in several files to enhance code readability.
- Simplified condition checks by consolidating method calls into single lines for better clarity.
- Improved formatting in various functions to maintain consistency across the codebase.
* fix(ci): use --bundles deb instead of unsupported none value
Tauri CLI on this version doesn't support 'none' as a bundle type.
Use 'deb' as the lightest single bundle to minimize packaging time.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* feat(ci): add Dockerfile and CI workflows for building and pushing Docker images
- Introduced a Dockerfile to set up a CI environment with necessary dependencies for Tauri, Rust, Node.js, and sccache.
- Created a new workflow to build and push the CI Docker image to GitHub Container Registry on main branch pushes.
- Updated existing workflows to utilize the new Docker image for building and testing, enhancing consistency and efficiency in CI processes.
* chore(ci): update container image references in CI workflows
- Removed unnecessary permissions for packages in build, test, and typecheck workflows.
- Updated container image references to use a specific digest instead of the latest tag for improved stability and reproducibility in CI processes.
* fix(ci): use correct amd64 Docker image digest
Previous digest was from arm64 build (Mac). Rebuilt with
--platform linux/amd64 for GitHub Actions runners.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(ci): use tag instead of digest for Docker image reference
GHCR doesn't support pulling OCI index manifests by digest reliably.
Use the rust-1.93.0 tag which is pinned to a specific Rust version
and resolves correctly on amd64 CI runners.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(ci): rename Docker package to openhuman_ci
Move from nested ghcr.io/tinyhumansai/openhuman/ci-runner to
ghcr.io/tinyhumansai/openhuman_ci to avoid GHCR nested package
manifest resolution issues.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(ci): remove sccache env vars from container jobs
sccache can't access the GHA cache API from inside a Docker container
(missing ACTIONS_CACHE_URL/ACTIONS_RUNTIME_TOKEN). Swatinem/rust-cache
already caches target/ which provides the main build speedup.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* chore: update installer smoke workflow to trigger on main branch pushes
- Added a trigger for the installer smoke workflow to run on pushes to the main branch, enhancing CI coverage for mainline changes.
* fix: enhance Sentry DSN retrieval logic
- Updated the Sentry DSN retrieval process to include an additional fallback option using `option_env!`, ensuring that the DSN can be sourced from both environment variables and optional configuration, improving robustness in observability setup.
* chore: add OPENHUMAN_SENTRY_DSN to release workflow and example secrets
- Included the OPENHUMAN_SENTRY_DSN variable in the release workflow configuration to enhance observability setup.
- Updated the ci-secrets.example.json file to include a placeholder for OPENHUMAN_SENTRY_DSN, providing clarity for developers on required environment variables.
---------
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* chore(workflows): comment out Windows smoke tests in installer and release workflows
* feat(observability): integrate Sentry for error reporting and add configuration support
- Added Sentry integration for error reporting in the application, initializing it in the main function.
- Introduced a new environment variable `OPENHUMAN_SENTRY_DSN` to configure Sentry DSN.
- Updated the observability configuration schema to include a field for Sentry DSN.
- Enhanced logging to include Sentry event filtering based on log levels.
- Implemented secret scrubbing to protect sensitive information in error reports.
* feat(analytics): add support for anonymized analytics settings
- Introduced new environment variable `OPENHUMAN_ANALYTICS_ENABLED` to enable or disable anonymized analytics and crash reports.
- Updated the PrivacyPanel component to sync analytics consent with the core configuration.
- Added new functions to handle analytics settings updates and retrieval in the Tauri backend.
- Enhanced observability configuration to include analytics settings, defaulting to enabled.
- Updated relevant schemas and handlers for analytics settings in the backend.
* refactor(tauriCommands): improve formatting and structure of analytics settings function
- Reformatted the `openhumanUpdateAnalyticsSettings` function for better readability by adjusting the parameter structure.
- Enhanced the output formatting in the `handle_get_analytics_settings` function for improved clarity in the JSON response.
* feat(analytics): sync analytics consent to core RPC and improve anonymization copy
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* 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.
