medicafe 0.251027.2__py3-none-any.whl → 0.251029.0__py3-none-any.whl

MediBot/MediBot.bat

@@ -732,7 +732,8 @@ echo 4. Toggle Performance Logging ^(session^)
 echo 5. Send TEST error report (email)
 echo 6. Forced MediCafe version rollback
 echo 7. Process CSV Files
-echo 8. Back to Main Menu
+echo 8. Edit Config File (JSON Editor)
+echo 9. Back to Main Menu
 echo.
 set /p tchoice=Enter your choice:  
 if "%tchoice%"=="1" goto open_latest_log
@@ -742,7 +743,8 @@ if "%tchoice%"=="4" goto toggle_perf_logging
 if "%tchoice%"=="5" goto send_test_error_report
 if "%tchoice%"=="6" goto forced_version_rollback
 if "%tchoice%"=="7" goto process_csvs
-if "%tchoice%"=="8" goto main_menu
+if "%tchoice%"=="8" goto config_editor
+if "%tchoice%"=="9" goto main_menu
 echo Invalid choice. Please try again.
 pause
 goto troubleshooting_menu
@@ -876,6 +878,14 @@ echo Rollback complete. Current MediCafe version: %medicafe_version%
 pause >nul
 goto troubleshooting_menu
 
+::: Config Editor
+:config_editor
+cls
+echo Starting Config Editor...
+call "%~dp0config_editor.bat"
+pause
+goto troubleshooting_menu
+
 ::: Subroutine to display the last N lines of a file
 :tail
 ::: Usage: call :tail filename number_of_lines

MediBot/__init__.py

@@ -19,7 +19,7 @@ Smart Import Integration:
         medibot_main = get_components('medibot_main')
 """
 
-__version__ = "0.251027.2"
+__version__ = "0.251029.0"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

MediBot/config_editor.bat

@@ -0,0 +1,90 @@
+@echo off
+setlocal enabledelayedexpansion
+
+:: Config Editor Launcher
+:: Called from MediBot.bat Troubleshooting menu
+
+:: Get script directory and set paths
+set "script_dir=%~dp0"
+set "workspace_root=%script_dir%.."
+set "python_script=%script_dir%config_editor.py"
+
+:: Use the same path resolution logic as MediLink_ConfigLoader
+:: Try default path first (relative to MediCafe module)
+set "config_path=%workspace_root%\json\config.json"
+
+:: If default path doesn't exist, try platform-specific fallbacks
+if not exist "%config_path%" (
+    :: Check for Windows XP (F: drive)
+    if exist "F:\" (
+        set "config_path=F:\Medibot\json\config.json"
+    ) else (
+        :: Use current working directory for other Windows versions
+        set "config_path=%CD%\json\config.json"
+    )
+)
+
+:: Display header
+cls
+echo ========================================
+echo        MediCafe Config Editor
+echo ========================================
+echo.
+
+:: Check if Python is available
+python --version >nul 2>&1
+if errorlevel 1 (
+    echo ERROR: Python is not available or not in PATH
+    echo.
+    echo Please ensure Python 3.4.4 or later is installed and accessible.
+    echo.
+    pause
+    exit /b 1
+)
+
+:: Check if config file exists
+if not exist "%config_path%" (
+    echo WARNING: Config file not found at:
+    echo %config_path%
+    echo.
+    echo The editor will start with an empty configuration.
+    echo You can create a new config file or navigate to the correct location.
+    echo.
+    set /p continue_choice="Continue anyway? (Y/N): "
+    if /i not "!continue_choice!"=="Y" (
+        echo Operation cancelled.
+        pause
+        exit /b 0
+    )
+)
+
+:: Check if editor script exists
+if not exist "%python_script%" (
+    echo ERROR: Config editor script not found at:
+    echo %python_script%
+    echo.
+    echo Please ensure config_editor.py is in the MediBot directory.
+    echo.
+    pause
+    exit /b 1
+)
+
+:: Run the config editor
+echo Starting config editor...
+echo.
+python "%python_script%" "%config_path%"
+
+:: Check exit code
+if errorlevel 1 (
+    echo.
+    echo ERROR: Config editor encountered an error.
+    echo.
+) else (
+    echo.
+    echo Config editor completed successfully.
+    echo.
+)
+
+:: Return to caller
+pause
+exit /b %errorlevel%

MediBot/config_editor.py

@@ -0,0 +1,430 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+DOS-Style Config.json Editor
+Interactive JSON configuration editor with DOS-like interface.
+Compatible with Python 3.4.4 and Windows XP.
+"""
+
+import os
+import sys
+import json
+from collections import OrderedDict
+
+# Import our helper functions
+from config_editor_helpers import (
+    load_config_safe, create_backup, save_config_atomic, validate_json_structure,
+    is_sensitive_key, get_value_type, format_value_for_display, clear_config_cache,
+    get_nested_value, set_nested_value, get_path_string, validate_key_name, parse_value_input,
+    resolve_config_path
+)
+
+class ConfigEditor:
+    def __init__(self, config_path):
+        self.config_path = config_path
+        self.config = OrderedDict()
+        self.original_config = OrderedDict()
+        self.current_path = []  # List of keys representing current location
+        self.staged_changes = []  # List of (path, old_value, new_value) tuples
+        self.running = True
+        
+        # Load initial config
+        self.config, error = load_config_safe(config_path)
+        if error:
+            print("WARNING: {}".format(error))
+            print("Starting with empty configuration.")
+            self.config = OrderedDict()
+        
+        # Keep a copy of original for comparison
+        self.original_config = json.loads(json.dumps(self.config, ensure_ascii=False), object_pairs_hook=OrderedDict)
+    
+    def clear_screen(self):
+        """Clear the console screen (XP compatible)."""
+        os.system('cls' if os.name == 'nt' else 'clear')
+    
+    def print_header(self):
+        """Print the editor header."""
+        print("=" * 60)
+        print("           MediCafe Config Editor")
+        print("=" * 60)
+        print("")
+    
+    def print_breadcrumb(self):
+        """Print current navigation path."""
+        path_str = get_path_string(self.current_path)
+        print("Current Path: {}".format(path_str))
+        print("-" * 60)
+    
+    def print_current_level(self):
+        """Print the current level of the config tree."""
+        current_data, found = get_nested_value(self.config, self.current_path)
+        
+        if not found:
+            print("ERROR: Invalid path")
+            return
+        
+        if not isinstance(current_data, dict):
+            print("ERROR: Cannot navigate into non-object value")
+            return
+        
+        if not current_data:
+            print("(Empty object)")
+            return
+        
+        # Print numbered items
+        items = list(current_data.items())
+        for i, (key, value) in enumerate(items, 1):
+            value_display = format_value_for_display(value)
+            value_type = get_value_type(value)
+            
+            # Mark sensitive keys
+            sensitive_mark = " [SENSITIVE]" if is_sensitive_key(key) else ""
+            
+            print("[{}] {}: {} ({}){}".format(i, key, value_display, value_type, sensitive_mark))
+    
+    def print_commands(self):
+        """Print available commands."""
+        print("")
+        print("Commands:")
+        print("  [1-N] Navigate/Edit  [0] Back  [EDIT #] Edit  [ADD] Add Key")
+        print("  [DIR] Refresh  [HELP] Help  [EXIT] Save & Exit")
+        print("-" * 60)
+    
+    def print_help(self):
+        """Print detailed help information."""
+        self.clear_screen()
+        self.print_header()
+        print("HELP - Config Editor Commands")
+        print("=" * 60)
+        print("")
+        print("Navigation:")
+        print("  [1-N]     - Navigate into nested objects or edit simple values")
+        print("  [0]       - Go back to parent level")
+        print("  [..]      - Same as [0]")
+        print("")
+        print("Editing:")
+        print("  [EDIT #]  - Edit the numbered item")
+        print("  [ADD]     - Add a new key at current level")
+        print("")
+        print("Utilities:")
+        print("  [DIR]     - Refresh current level display")
+        print("  [HELP]    - Show this help screen")
+        print("  [EXIT]    - Save changes and exit")
+        print("  [Q]       - Same as [EXIT]")
+        print("")
+        print("Safety Features:")
+        print("  - All changes are staged until you save")
+        print("  - Automatic backup created before saving")
+        print("  - Sensitive keys marked with [SENSITIVE]")
+        print("  - Preview all changes before committing")
+        print("")
+        print("Press Enter to continue...")
+        input()
+    
+    def navigate_to_item(self, item_number):
+        """Navigate to a numbered item."""
+        current_data, found = get_nested_value(self.config, self.current_path)
+        
+        if not found or not isinstance(current_data, dict):
+            print("ERROR: Cannot navigate from current location")
+            return
+        
+        items = list(current_data.items())
+        if item_number < 1 or item_number > len(items):
+            print("ERROR: Invalid item number")
+            return
+        
+        key, value = items[item_number - 1]
+        
+        # If it's a simple value, offer to edit it
+        if not isinstance(value, dict):
+            self.edit_simple_value(key, value)
+        else:
+            # Navigate into the object
+            self.current_path.append(key)
+    
+    def edit_simple_value(self, key, current_value):
+        """Edit a simple (non-object) value."""
+        current_type = get_value_type(current_value)
+        current_display = format_value_for_display(current_value)
+        
+        print("")
+        print("Editing: {}".format(key))
+        print("Current value: {} ({})".format(current_display, current_type))
+        print("")
+        
+        # Get new value
+        new_value_str = input("Enter new value: ").strip()
+        
+        if not new_value_str:
+            print("No changes made.")
+            return
+        
+        # Parse the new value
+        new_value, error = parse_value_input(new_value_str, current_type)
+        if error:
+            print("ERROR: {}".format(error))
+            return
+        
+        # Show preview
+        new_display = format_value_for_display(new_value)
+        print("")
+        print("Preview: {} -> {}".format(current_display, new_display))
+        
+        # Confirm change
+        if is_sensitive_key(key):
+            print("WARNING: This appears to be a sensitive key!")
+        
+        confirm = input("Apply this change? (Y/N): ").strip().upper()
+        if confirm in ['Y', 'YES']:
+            # Stage the change
+            full_path = self.current_path + [key]
+            self.staged_changes.append((full_path, current_value, new_value))
+            set_nested_value(self.config, full_path, new_value)
+            print("Change staged.")
+        else:
+            print("Change cancelled.")
+    
+    def add_new_key(self):
+        """Add a new key at the current level."""
+        current_data, found = get_nested_value(self.config, self.current_path)
+        
+        if not found or not isinstance(current_data, dict):
+            print("ERROR: Cannot add key at current location")
+            return
+        
+        print("")
+        print("Add New Key")
+        print("-" * 30)
+        
+        # Get key name
+        while True:
+            key_name = input("Enter key name: ").strip()
+            is_valid, error = validate_key_name(key_name, current_data.keys())
+            if is_valid:
+                break
+            print("ERROR: {}".format(error))
+        
+        # Get value type
+        print("")
+        print("Value types:")
+        print("  1. string   - Text value")
+        print("  2. number   - Numeric value")
+        print("  3. boolean  - true/false")
+        print("  4. array    - List of values")
+        print("  5. object   - Nested structure")
+        print("")
+        
+        while True:
+            type_choice = input("Select value type (1-5): ").strip()
+            type_map = {'1': 'string', '2': 'number', '3': 'boolean', '4': 'array', '5': 'object'}
+            if type_choice in type_map:
+                value_type = type_map[type_choice]
+                break
+            print("ERROR: Invalid choice. Enter 1-5.")
+        
+        # Get value based on type
+        if value_type == 'string':
+            value_input = input("Enter string value: ").strip()
+        elif value_type == 'number':
+            value_input = input("Enter number value: ").strip()
+        elif value_type == 'boolean':
+            value_input = input("Enter boolean value (true/false): ").strip()
+        elif value_type == 'array':
+            value_input = input("Enter array values (comma-separated): ").strip()
+        elif value_type == 'object':
+            value_input = ""  # Empty object
+            print("Creating empty object. You can add keys to it later.")
+        
+        # Parse the value
+        new_value, error = parse_value_input(value_input, value_type)
+        if error:
+            print("ERROR: {}".format(error))
+            return
+        
+        # Show preview
+        new_display = format_value_for_display(new_value)
+        print("")
+        print("Preview: {}: {} ({})".format(key_name, new_display, value_type))
+        
+        # Confirm addition
+        if is_sensitive_key(key_name):
+            print("WARNING: This appears to be a sensitive key!")
+        
+        confirm = input("Add this key? (Y/N): ").strip().upper()
+        if confirm in ['Y', 'YES']:
+            # Stage the change
+            full_path = self.current_path + [key_name]
+            self.staged_changes.append((full_path, None, new_value))
+            set_nested_value(self.config, full_path, new_value)
+            print("Key added and staged.")
+        else:
+            print("Addition cancelled.")
+    
+    def show_staged_changes(self):
+        """Show all staged changes."""
+        if not self.staged_changes:
+            print("No staged changes.")
+            return
+        
+        print("")
+        print("Staged Changes:")
+        print("-" * 30)
+        
+        for i, (path, old_value, new_value) in enumerate(self.staged_changes, 1):
+            path_str = " > ".join(path)
+            if old_value is None:
+                print("{}. ADD: {} = {}".format(i, path_str, format_value_for_display(new_value)))
+            else:
+                print("{}. EDIT: {} = {} -> {}".format(
+                    i, path_str, 
+                    format_value_for_display(old_value), 
+                    format_value_for_display(new_value)
+                ))
+    
+    def save_changes(self):
+        """Save all staged changes to file."""
+        if not self.staged_changes:
+            print("No changes to save.")
+            return True
+        
+        print("")
+        print("Saving Changes...")
+        print("-" * 30)
+        
+        # Show summary
+        self.show_staged_changes()
+        print("")
+        
+        # Validate JSON structure
+        is_valid, error = validate_json_structure(self.config)
+        if not is_valid:
+            print("ERROR: {}".format(error))
+            return False
+        
+        # Create backup
+        backup_path = create_backup(self.config_path)
+        if backup_path:
+            print("Backup created: {}".format(os.path.basename(backup_path)))
+        else:
+            print("WARNING: Could not create backup")
+        
+        # Save to file
+        success, error = save_config_atomic(self.config_path, self.config)
+        if not success:
+            print("ERROR: {}".format(error))
+            return False
+        
+        # Clear cache
+        cache_success, cache_error = clear_config_cache()
+        if not cache_success:
+            print("WARNING: {}".format(cache_error))
+        
+        print("Configuration saved successfully!")
+        return True
+    
+    def process_command(self, command):
+        """Process a user command."""
+        command = command.strip().upper()
+        
+        if command == 'EXIT' or command == 'Q':
+            if self.staged_changes:
+                print("")
+                print("You have unsaved changes.")
+                self.show_staged_changes()
+                print("")
+                save_choice = input("Save changes before exiting? (Y/N): ").strip().upper()
+                if save_choice in ['Y', 'YES']:
+                    if self.save_changes():
+                        self.running = False
+                else:
+                    print("Changes discarded.")
+                    self.running = False
+            else:
+                self.running = False
+        
+        elif command == 'HELP':
+            self.print_help()
+        
+        elif command == 'DIR':
+            pass  # Will refresh display
+        
+        elif command == 'ADD':
+            self.add_new_key()
+        
+        elif command.startswith('EDIT '):
+            try:
+                item_num = int(command[5:].strip())
+                self.navigate_to_item(item_num)
+            except ValueError:
+                print("ERROR: Invalid EDIT command. Use EDIT followed by a number.")
+        
+        elif command == '0' or command == '..':
+            if self.current_path:
+                self.current_path.pop()
+            else:
+                print("Already at root level.")
+        
+        elif command.isdigit():
+            item_num = int(command)
+            self.navigate_to_item(item_num)
+        
+        else:
+            print("ERROR: Unknown command '{}'. Type HELP for available commands.".format(command))
+    
+    def run(self):
+        """Main editor loop."""
+        while self.running:
+            self.clear_screen()
+            self.print_header()
+            self.print_breadcrumb()
+            self.print_current_level()
+            self.print_commands()
+            
+            if self.staged_changes:
+                print("")
+                print("You have {} unsaved changes.".format(len(self.staged_changes)))
+            
+            try:
+                command = input("Config> ").strip()
+                if command:
+                    self.process_command(command)
+            except KeyboardInterrupt:
+                print("\n")
+                print("Interrupted by user.")
+                if self.staged_changes:
+                    save_choice = input("Save changes before exiting? (Y/N): ").strip().upper()
+                    if save_choice in ['Y', 'YES']:
+                        self.save_changes()
+                break
+            except EOFError:
+                break
+        
+        print("Config editor closed.")
+
+def main():
+    """Main entry point."""
+    if len(sys.argv) != 2:
+        print("Usage: python config_editor.py <config_path>")
+        sys.exit(1)
+    
+    # Resolve the config path using the same logic as MediLink_ConfigLoader
+    default_path = sys.argv[1]
+    config_path = resolve_config_path(default_path)
+    
+    # Ensure the directory exists (create it if needed)
+    config_dir = os.path.dirname(config_path)
+    if not os.path.exists(config_dir):
+        try:
+            os.makedirs(config_dir)
+        except OSError as e:
+            # Ignore error if directory already exists (race condition)
+            if e.errno != 17:  # EEXIST
+                print("ERROR: Could not create config directory '{}': {}".format(config_dir, str(e)))
+                sys.exit(1)
+    
+    editor = ConfigEditor(config_path)
+    editor.run()
+
+if __name__ == "__main__":
+    main()