Add persistent vars, status aliases, and tray timer UX/audio updates

Author: Jeetski

commands/set.py

@@ -1,11 +1,146 @@
 import sys
+import os
+import yaml
 from modules.item_manager import read_item_data, write_item_data
 from modules import variables as Variables
+from modules import status_utils
+from modules.scheduler import status_current_path
 
 # --- Global Variables for Scripting ---
 # This dictionary stores variables set by the 'set var' command.
 # In a more robust system, this would be managed by the Console or a dedicated scripting engine
 GLOBAL_VARS = {}
+ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+PROFILE_PATH = os.path.join(ROOT_DIR, "user", "profile", "profile.yml")
+TIMER_SETTINGS_PATH = os.path.join(ROOT_DIR, "user", "settings", "timer_settings.yml")
+TIMER_PROFILES_PATH = os.path.join(ROOT_DIR, "user", "settings", "timer_profiles.yml")
+
+def _sync_status_var_to_yaml(var_name: str, var_value: str):
+    """
+    Persist `status_*` variable assignments to current_status.yml and keep
+    runtime mirrored vars in sync.
+    """
+    raw_name = str(var_name or "").strip()
+    if not raw_name.lower().startswith("status_"):
+        return None, None
+
+    indicator = status_utils.status_slug(raw_name[len("status_"):])
+    if not indicator:
+        return "Invalid status variable name.", None
+    normalized_value, err = status_utils.canonicalize_status_value(indicator, var_value)
+    if err:
+        return err, None
+
+    path = status_current_path()
+    try:
+        if os.path.exists(path):
+            with open(path, "r", encoding="utf-8") as f:
+                current = yaml.safe_load(f) or {}
+        else:
+            current = {}
+        if not isinstance(current, dict):
+            current = {}
+    except Exception:
+        current = {}
+
+    current[indicator] = normalized_value
+    try:
+        with open(path, "w", encoding="utf-8") as f:
+            yaml.dump(current, f, default_flow_style=False)
+    except Exception as e:
+        return f"Failed to write status file: {e}", None
+
+    try:
+        Variables.sync_status_vars(current)
+    except Exception:
+        pass
+    return None, str(normalized_value)
+
+
+def _sync_nickname_var_to_profile(var_name: str, var_value: str):
+    """
+    Persist nickname variable assignment to profile.yml and keep runtime var
+    aligned with profile source-of-truth.
+    """
+    raw_name = str(var_name or "").strip().lower()
+    if raw_name != "nickname":
+        return None, None
+
+    nickname = str(var_value or "").strip()
+    if not nickname:
+        return "Nickname cannot be empty.", None
+
+    profile = {}
+    try:
+        if os.path.exists(PROFILE_PATH):
+            with open(PROFILE_PATH, "r", encoding="utf-8") as f:
+                profile = yaml.safe_load(f) or {}
+        if not isinstance(profile, dict):
+            profile = {}
+    except Exception:
+        profile = {}
+
+    profile["nickname"] = nickname
+    try:
+        os.makedirs(os.path.dirname(PROFILE_PATH), exist_ok=True)
+        with open(PROFILE_PATH, "w", encoding="utf-8") as f:
+            yaml.dump(profile, f, default_flow_style=False, sort_keys=False)
+    except Exception as e:
+        return f"Failed to write profile nickname: {e}", None
+
+    return None, nickname
+
+
+def _sync_timer_profile_var_to_settings(var_name: str, var_value: str):
+    """
+    Persist timer_profile variable assignment to timer_settings.yml.
+    Validates profile exists in timer_profiles.yml when available.
+    """
+    raw_name = str(var_name or "").strip().lower()
+    if raw_name != "timer_profile":
+        return None, None
+
+    profile_name = str(var_value or "").strip()
+    if not profile_name:
+        return "Timer profile cannot be empty.", None
+
+    profiles = {}
+    try:
+        if os.path.exists(TIMER_PROFILES_PATH):
+            with open(TIMER_PROFILES_PATH, "r", encoding="utf-8") as f:
+                profiles = yaml.safe_load(f) or {}
+        if not isinstance(profiles, dict):
+            profiles = {}
+    except Exception:
+        profiles = {}
+
+    if profiles and profile_name not in profiles:
+        # Case-insensitive convenience for profile selection.
+        lower_map = {str(k).lower(): str(k) for k in profiles.keys()}
+        match = lower_map.get(profile_name.lower())
+        if not match:
+            return f"Unknown timer profile '{profile_name}'.", None
+        profile_name = match
+
+    settings = {}
+    try:
+        if os.path.exists(TIMER_SETTINGS_PATH):
+            with open(TIMER_SETTINGS_PATH, "r", encoding="utf-8") as f:
+                settings = yaml.safe_load(f) or {}
+        if not isinstance(settings, dict):
+            settings = {}
+    except Exception:
+        settings = {}
+
+    settings["default_profile"] = profile_name
+    try:
+        os.makedirs(os.path.dirname(TIMER_SETTINGS_PATH), exist_ok=True)
+        with open(TIMER_SETTINGS_PATH, "w", encoding="utf-8") as f:
+            yaml.dump(settings, f, default_flow_style=False, sort_keys=False)
+    except Exception as e:
+        return f"Failed to write timer settings: {e}", None
+
+    return None, profile_name
 
 
 def run(args, properties):
@@ -41,9 +176,44 @@ def run(args, properties):
 
         var_assignment = args[1]
         if ':' in var_assignment:
-            var_name, var_value = var_assignment.split(':', 1)
-            Variables.set_var(var_name, var_value)
-            print(f"✅. Variable '{var_name}' set to '{var_value}'.")
+            raw_var_name, var_value = var_assignment.split(':', 1)
+            var_name = Variables.canonical_var_name(raw_var_name)
+            err, normalized_status_value = _sync_status_var_to_yaml(var_name, var_value)
+            if err:
+                print(f"❌ {err}")
+                return
+            normalized_nickname_value = None
+            normalized_timer_profile_value = None
+            if normalized_status_value is None:
+                nick_err, normalized_nickname_value = _sync_nickname_var_to_profile(var_name, var_value)
+                if nick_err:
+                    print(f"❌ {nick_err}")
+                    return
+            if normalized_status_value is None and normalized_nickname_value is None:
+                timer_err, normalized_timer_profile_value = _sync_timer_profile_var_to_settings(var_name, var_value)
+                if timer_err:
+                    print(f"❌ {timer_err}")
+                    return
+            final_value = (
+                normalized_status_value
+                if normalized_status_value is not None
+                else normalized_nickname_value
+                if normalized_nickname_value is not None
+                else normalized_timer_profile_value
+                if normalized_timer_profile_value is not None
+                else var_value
+            )
+            Variables.set_var(var_name, final_value)
+            if str(raw_var_name).strip() != str(var_name).strip():
+                print(f"✅. Variable '{raw_var_name}' (alias of '{var_name}') set to '{final_value}'.")
+            else:
+                print(f"✅. Variable '{var_name}' set to '{final_value}'.")
+            if str(var_name).strip().lower().startswith("status_"):
+                print("↳ Synced to current_status.yml")
+            elif str(var_name).strip().lower() == "nickname":
+                print("↳ Synced to profile.yml")
+            elif str(var_name).strip().lower() == "timer_profile":
+                print("↳ Synced to timer_settings.yml")
         else:
             print(f"❌ Invalid variable assignment: {var_assignment}. Expected format: <variable_name>:<value>")
         return
@@ -148,6 +318,10 @@ def get_help_message():
 Description: Sets properties of an item or defines a script variable.
 Example: set note MyMeetingNotes priority:high category:work
 Example: set var my_variable:some_value
+Example: set var status_energy:high   # updates var and current_status.yml
+Example: set var location:home        # alias of status_place; updates current_status.yml
+Example: set var nickname:Alice       # updates var and user/profile/profile.yml
+Example: set var timer_profile:classic_pomodoro  # updates var and user/settings/timer_settings.yml
 
 Special (goals):
   set goal "<name>" template:true      # mark goal as a template

commands/status.py

@@ -3,6 +3,7 @@
 from datetime import datetime
 from modules.scheduler import status_current_path, status_history_path_for_date
 from modules import status_utils
+from modules import variables as Variables
 
 def run(args, properties):
     status_file_path = status_current_path()
@@ -18,6 +19,10 @@ def run(args, properties):
                 with open(status_file_path, 'r') as f:
                     current_status = yaml.safe_load(f)
                     if current_status:
+                        try:
+                            Variables.sync_status_vars(current_status)
+                        except Exception:
+                            pass
                         print("Current Status:")
                         for key, value in current_status.items():
                             print(f"  {key}: {value}")
@@ -64,6 +69,10 @@ def run(args, properties):
         # Write updated status
         with open(status_file_path, 'w') as f:
             yaml.dump(current_status, f, default_flow_style=False)
+        try:
+            Variables.sync_status_vars(current_status)
+        except Exception:
+            pass
 
         # Append to dated status history
         history_path = status_history_path_for_date(datetime.now())
@@ -99,7 +108,17 @@ def run(args, properties):
         print(f"❌ An unexpected error occurred: {e}")
 
 def get_help_message():
-    return "Views or sets user status variables.\n\nUsage: status <indicator>:<value>\n       status (to view current status)\n\nExamples:\n  status emotion:happy\n  status energy:low"
+    return (
+        "Views or sets user status values.\n\n"
+        "Usage: status <indicator>:<value>\n"
+        "       status (to view current status)\n\n"
+        "Runtime variable mirror:\n"
+        "  Current status values are also exposed as @status_<indicator>\n"
+        "  Example: @status_energy, @status_focus\n\n"
+        "Examples:\n"
+        "  status emotion:happy\n"
+        "  status energy:low"
+    )
 
 if __name__ == '__main__':
     # This block is for testing the command directly

commands/vars.py

@@ -10,7 +10,7 @@ def run(args, properties):
     name = properties.get('name')
 
     if name:
-        val = vars_map.get(name)
+        val = Variables.get_var(name)
         if val is None:
             print(f"No variable named '{name}'.")
         else:
@@ -31,5 +31,6 @@ def get_help_message():
 Description: Lists current script variables or a single variable by name.
 Example: vars
 Example: vars name:project
+Example: vars name:status_energy
 """
 

docs/dev/architecture.md

@@ -7,7 +7,7 @@ This guide explains how Chronos fits together so you can extend it confidently.
 - CLI Entrypoint — `modules/console.py`
   - Adds project paths, sets UTF-8, and loads `commands/*.py` dynamically.
   - Parses interactive input, CLI args, and `.chs` scripts (supports nested `if/elseif/else/end` and loop blocks).
-  - Uses `modules/variables.py` for in-memory variables and token expansion (e.g., `@nickname`).
+  - Uses `modules/variables.py` for in-memory variables and token expansion (e.g., `@nickname`, `@status_energy`).
   - Macro hooks: command execution is wrapped with BEFORE/AFTER hooks via `modules/macro_engine.py` (enabled by `user/scripts/macros/macros.yml`). Dashboard calls also pass through these hooks.
   - Autosuggest and autocomplete are registry-driven; see `docs/dev/autosuggest.md` for the slot model and refresh workflow.
 

docs/dev/chs_scripting.md

@@ -6,6 +6,10 @@ Chronos executes `.chs` scripts with one command per line. Lines support quoted
 
 - Set a variable: `set var name:World`
 - Use in any command: `echo Hello @name` or `echo Hello @{name}`
+- Current status is mirrored to vars like `@status_energy`, `@status_focus`, `@status_health`
+- `@location` is an alias of `@status_place` (for example, `set var location:home`)
+- Setting `status_*` vars writes through to status YAML: `set var status_energy:high`
+- `@timer_profile` mirrors timer default profile; set with `set var timer_profile:classic_pomodoro`
 - Escape a literal `@`: use `@@`
 - Scope: Variables persist for the duration of the current console session or script execution.
 - Inspect and remove:
@@ -61,6 +65,7 @@ create note "IF Note @who" category:work priority:high
 
 if exists note:"IF Note @who" then echo FOUND else echo MISSING
 if status:energy eq high and exists env:PATH then echo READY
+if @status_energy eq high and exists env:PATH then echo READY
 if note:"IF Note @who":priority matches ^h.* then echo STARTS_WITH_H
 if ( status:energy eq high and exists note:"IF Note @who" ) or status:emotion ne sad then echo OK
 

docs/documentation_overview.md

@@ -123,7 +123,7 @@ today reschedule
 ### 4. CHS Scripting Language
 
 **Features**:
-- Variables: `@nickname`, `@var`, `@{var}`
+- Variables: `@nickname`, `@status_energy`, `@status_focus`, `@location` (alias `@status_place`), `@timer_profile`, `@var`, `@{var}`
 - Conditionals: `if/elseif/else/end` (block and single-line)
 - Loops: `repeat`, `for`, `while` (bounded)
 - Operators: `== != > < >= <= matches` (regex)

docs/guides/common_workflows.md

@@ -436,6 +436,7 @@ Scripts (Automation)
 
 - Variables
   - Use `@nickname` (from `user/profile/profile.yml`) in messages.
+  - Use mirrored status vars in scripts/macros (for example `@status_energy`, `@status_focus`).
   - Set inside scripts with `set var <name> <value>` or via specific command outputs.
 
 ----------------------------------------

docs/readme.md

@@ -127,6 +127,9 @@ Common commands (all item types now share the same verbs via `handle_command`)
 
 Variables
 - The console seeds `@nickname` from `user/profile/profile.yml`. Use in scripts/messages.
+- Current status values are mirrored as runtime vars like `@status_energy`, `@status_focus`, `@status_health`.
+- `@location` is an alias of `@status_place` (same source, no duplicate storage).
+- Timer default profile is mirrored as `@timer_profile` (from `user/settings/timer_settings.yml`).
 - Set/read variables programmatically via `modules/variables.py` or CLI patterns.
 
 ## Dashboard

docs/reference/cli_commands.md

@@ -31,6 +31,10 @@ Appends text to the content of an existing item.
 ### `set`
 Sets properties of an item or defines a script variable.
 **Usage:** `set <type> <name> <property_key>:<value> [...]`
+**Notes:**
+- `set var status_<indicator>:<value>` also updates `user/current_status.yml` (same source used by `status`).
+- `set var location:<value>` is an alias for `set var status_place:<value>`.
+- `set var timer_profile:<name>` updates `user/settings/timer_settings.yml` (`default_profile`).
 
 ### `get`
 Retrieves the value of a specific property from an item.
@@ -171,6 +175,8 @@ Views or sets user status variables.
 **Usage:**
 - `status`
 - `status <indicator>:<value>`
+**Notes:**
+- Current status values are mirrored to runtime vars such as `@status_energy` and `@status_focus`.
 
 ### `complete`
 Marks an item as completed.
@@ -551,6 +557,10 @@ Runs a command while a condition remains true (bounded).
 ### `vars`
 Lists current script variables or a single variable by name.
 **Usage:** `vars [name:<varname>]`
+**Examples:**
+- `vars`
+- `vars name:project`
+- `vars name:status_energy`
 
 ### `unset`
 Removes a script variable from the current session.

modules/console.py

@@ -637,6 +637,32 @@ def _load_profile_and_seed_vars():
                     Variables.set_var('nickname', nick)
                 except Exception:
                     pass
+
+        # Mirror current status values into runtime vars (e.g., @status_energy).
+        status_candidates = [
+            os.path.join(ROOT_DIR, "user", "current_status.yml"),
+            os.path.join(ROOT_DIR, "user", "profile", "current_status.yml"),
+        ]
+        status_map = {}
+        for path in status_candidates:
+            data = _safe_load_yaml(path)
+            if isinstance(data, dict):
+                status_map = data
+                break
+        try:
+            Variables.sync_status_vars(status_map)
+        except Exception:
+            pass
+
+        # Mirror timer default profile into runtime var.
+        try:
+            timer_cfg = _safe_load_yaml(os.path.join(ROOT_DIR, "user", "settings", "timer_settings.yml")) or {}
+            if isinstance(timer_cfg, dict):
+                default_profile = str(timer_cfg.get("default_profile") or "").strip()
+                if default_profile:
+                    Variables.set_var("timer_profile", default_profile)
+        except Exception:
+            pass
     except Exception:
         pass