Struct Config 

pub struct Config {
    pub si: Option<SiConfig>,
    pub gitlab: Option<GitLabConfig>,
    pub jira: Option<JiraConfig>,
    pub monitor: Option<MonitorConfig>,
    pub server: Option<ServerConfig>,
    pub productivity: Option<ProductivityConfig>,
    pub report: Option<ReportConfig>,
    pub task_discovery: Option<TaskDiscoveryConfig>,
    pub jira_inbox: Option<JiraInboxConfig>,
}

Main configuration container for the entire application.

This structure serves as the root configuration object that encompasses all service integrations and system settings. Each field represents an optional module that can be configured independently, allowing users to enable only the integrations they need.

Optional Configuration Pattern

All service configurations are optional (Option<T>), which provides several benefits:

• Users can configure only the services they use
• Missing configurations don’t break the application
• New integrations can be added without breaking existing setups
• Configuration files remain clean and focused

Serialization Behavior

The skip_serializing_if = "Option::is_none" attribute ensures that unconfigured services are omitted from the JSON output, keeping configuration files clean and readable.

Fields

si: Option<SiConfig>

SearchInform internal API configuration.

When configured, enables integration with company-specific APIs for advanced reporting and task management features.

gitlab: Option<GitLabConfig>

GitLab API integration configuration.

Enables automatic discovery of commits and merge requests for task creation and progress tracking.

jira: Option<JiraConfig>

Jira API integration configuration.

Provides access to issue tracking for automatic task import and work item synchronization.

monitor: Option<MonitorConfig>

Activity monitoring configuration.

Controls the behavior of the background process that tracks user activity and manages work time detection.

server: Option<ServerConfig>

External reporting server configuration.

Enables submission of reports to external time tracking or project management systems.

productivity: Option<ProductivityConfig>

Productivity management configuration.

Controls productivity thresholds, break recommendations, and report validation based on productivity metrics.

report: Option<ReportConfig>

Daily report export configuration.

Controls the default output directory and file name template used when exporting reports without an explicit output path.

task_discovery: Option<TaskDiscoveryConfig>

Task discovery settings for kasl task --find.

Holds the ignore list used to filter out noisy commits and tasks. When absent, built-in defaults are applied at runtime.

jira_inbox: Option<JiraInboxConfig>

Background Jira inbox polling and toast notifications.

Requires jira to be configured. When absent, inbox polling is disabled.

Implementations

impl Config

pub fn read() -> Result<Config>

Reads configuration from the filesystem.

This method attempts to load the configuration file from the platform-specific application data directory. If no configuration file exists, it returns a default configuration with all modules disabled, allowing the application to function with minimal setup.

File Location

The configuration file location varies by platform:

• Windows: %LOCALAPPDATA%\lacodda\kasl\config.json
• macOS: ~/Library/Application Support/lacodda/kasl/config.json
• Linux: ~/.local/share/lacodda/kasl/config.json

Error Handling

• Missing file: Returns default configuration (not an error)
• Corrupted file: Returns parsing error
• Permission issues: Returns filesystem error

Returns

Returns the loaded configuration or a default configuration if no file exists.

Errors

Returns an error if the configuration file exists but cannot be read or parsed.

Examples

use kasl::libs::config::Config;

// Load configuration, falling back to defaults if no file exists
let config = Config::read()?;

// Check if Jira is configured
if config.jira.is_some() {
    println!("Jira integration is configured");
}

pub fn save(&self) -> Result<()>

Saves the current configuration to the filesystem.

This method serializes the configuration to JSON format and writes it to the platform-specific application data directory. The JSON is formatted with proper indentation for human readability and manual editing.

File Operations

• Creates the application data directory if it doesn’t exist
• Overwrites any existing configuration file
• Uses pretty-printing for readable JSON output
• Sets appropriate file permissions for user-only access

Returns

Returns Ok(()) on successful save, or an error if the file cannot be written.

Errors

Returns an error if:

• The application data directory cannot be created
• The configuration file cannot be written due to permission issues
• JSON serialization fails (should not happen with valid configurations)

Examples

use kasl::libs::config::{Config, MonitorConfig};

let mut config = Config::read()?;
config.monitor = Some(MonitorConfig::default());
config.save()?;

pub fn effective_ignore_names(&self) -> Vec<String>

Returns the ignore list for task discovery.

When task_discovery is not configured, returns the built-in defaults.

pub fn add_ignore_names(&mut self, names: &[String]) -> Result<usize>

Appends unique names to the discovery ignore list and saves the config.

Uniqueness is determined by normalize_task_name. Returns how many new entries were added.

pub fn init() -> Result<Self>

Runs an interactive configuration setup wizard.

This method provides a comprehensive guided setup experience that allows users to configure multiple application modules through an interactive command-line interface. The wizard presents available modules, collects configuration parameters, and validates inputs before saving.

Setup Process

1. Load Current Config: Starts with existing configuration as defaults
2. Module Selection: Presents a multi-select list of available integrations
3. Parameter Collection: For each selected module, prompts for required settings
4. Validation: Performs basic validation on input parameters
5. Configuration Return: Returns the updated configuration for saving

Available Modules

• SI (SearchInform): Company-specific API integration
• GitLab: Source control integration for commit tracking
• Jira: Issue tracking integration for task management
• Monitor: Activity monitoring and pause detection settings
• Server: External reporting API configuration

User Experience

• Uses colored prompts for better visual feedback
• Pre-fills existing values as defaults to simplify updates
• Provides helpful descriptions for each configuration parameter
• Allows partial configuration (users can skip unwanted modules)

Returns

Returns a fully configured Config instance ready for saving.

Errors

Returns an error if:

• The existing configuration cannot be loaded
• User input cannot be collected due to terminal issues
• A module’s configuration setup fails

Examples

use kasl::libs::config::Config;

// Run interactive setup and save the result
let config = Config::init()?;
config.save()?;

pub fn set_app_global() -> Result<()>

Adds the application to the global system PATH.

This method ensures that the kasl executable can be run from any directory by adding its location to the system’s PATH environment variable. This is particularly useful on Windows where applications are not automatically available globally after installation.

Platform Behavior

• Windows: Modifies the system registry to update the global PATH
• Unix-like: Currently not implemented (uses shell integration instead)

Windows Implementation Details

The Windows implementation:

1. Determines the current executable’s directory
2. Checks if the directory is already in the PATH
3. Updates the registry to add the directory if needed
4. Requires administrative privileges for system-wide changes

Security Considerations

• Modifying the system PATH requires elevated privileges on Windows
• Changes affect all users on the system
• The operation is reversible by manually editing the PATH

Returns

Returns Ok(()) if the PATH was successfully updated or was already correct.

Errors

Returns an error if:

• The current executable path cannot be determined
• Registry operations fail due to insufficient privileges
• System commands fail to execute properly

Examples

use kasl::libs::config::Config;

// Ensure kasl is available globally
Config::set_app_global()?;

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Config

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Config

fn default() -> Self

Creates a default configuration with all modules disabled.

This provides a clean starting point for new installations where users can selectively enable and configure only the services they need. All optional configurations are set to None, requiring explicit setup through the interactive configuration system or manual editing.

impl<'de> Deserialize<'de> for Config

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Config

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.