@machina.ai/cell-cli 1.4.0-rc2 → 1.6.1-rc1

package/dist/src/utils/settingsUtils.test.js

@@ -8,14 +8,140 @@ import {
 // Schema utilities
 getSettingsByCategory, getSettingDefinition, requiresRestart, getDefaultValue, getRestartRequiredSettings, getEffectiveValue, getAllSettingKeys, getSettingsByType, getSettingsRequiringRestart, isValidSettingKey, getSettingCategory, shouldShowInDialog, getDialogSettingsByCategory, getDialogSettingsByType, getDialogSettingKeys, 
 // Business logic utilities
-getSettingValue, isSettingModified, settingExistsInScope, setPendingSettingValue, hasRestartRequiredSettings, getRestartRequiredFromModified, getDisplayValue, isDefaultValue, isValueInherited, getEffectiveDisplayValue, } from './settingsUtils.js';
+getSettingValue, isSettingModified, TEST_ONLY, settingExistsInScope, setPendingSettingValue, hasRestartRequiredSettings, getRestartRequiredFromModified, getDisplayValue, isDefaultValue, isValueInherited, getEffectiveDisplayValue, } from './settingsUtils.js';
+import { getSettingsSchema, } from '../config/settingsSchema.js';
+vi.mock('../config/settingsSchema.js', async (importOriginal) => {
+    const original = await importOriginal();
+    return {
+        ...original,
+        getSettingsSchema: vi.fn(),
+    };
+});
+function makeMockSettings(settings) {
+    return settings;
+}
 describe('SettingsUtils', () => {
+    beforeEach(() => {
+        const SETTINGS_SCHEMA = {
+            mcpServers: {
+                type: 'object',
+                label: 'MCP Servers',
+                category: 'Advanced',
+                requiresRestart: true,
+                default: {},
+                description: 'Configuration for MCP servers.',
+                showInDialog: false,
+            },
+            test: {
+                type: 'string',
+                label: 'Test',
+                category: 'Basic',
+                requiresRestart: false,
+                default: 'hello',
+                description: 'A test field',
+                showInDialog: true,
+            },
+            advanced: {
+                type: 'object',
+                label: 'Advanced',
+                category: 'Advanced',
+                requiresRestart: true,
+                default: {},
+                description: 'Advanced settings for power users.',
+                showInDialog: false,
+            },
+            ui: {
+                type: 'object',
+                label: 'UI',
+                category: 'UI',
+                requiresRestart: false,
+                default: {},
+                description: 'User interface settings.',
+                showInDialog: false,
+                properties: {
+                    theme: {
+                        type: 'string',
+                        label: 'Theme',
+                        category: 'UI',
+                        requiresRestart: false,
+                        default: undefined,
+                        description: 'The color theme for the UI.',
+                        showInDialog: false,
+                    },
+                    requiresRestart: {
+                        type: 'boolean',
+                        label: 'Requires Restart',
+                        category: 'UI',
+                        default: false,
+                        requiresRestart: true,
+                    },
+                    accessibility: {
+                        type: 'object',
+                        label: 'Accessibility',
+                        category: 'UI',
+                        requiresRestart: true,
+                        default: {},
+                        description: 'Accessibility settings.',
+                        showInDialog: false,
+                        properties: {
+                            disableLoadingPhrases: {
+                                type: 'boolean',
+                                label: 'Disable Loading Phrases',
+                                category: 'UI',
+                                requiresRestart: true,
+                                default: false,
+                                description: 'Disable loading phrases for accessibility',
+                                showInDialog: true,
+                            },
+                        },
+                    },
+                },
+            },
+            tools: {
+                type: 'object',
+                label: 'Tools',
+                category: 'Tools',
+                requiresRestart: false,
+                default: {},
+                description: 'Tool settings.',
+                showInDialog: false,
+                properties: {
+                    shell: {
+                        type: 'object',
+                        label: 'Shell',
+                        category: 'Tools',
+                        requiresRestart: false,
+                        default: {},
+                        description: 'Shell tool settings.',
+                        showInDialog: false,
+                        properties: {
+                            pager: {
+                                type: 'string',
+                                label: 'Pager',
+                                category: 'Tools',
+                                requiresRestart: false,
+                                default: 'less',
+                                description: 'The pager to use for long output.',
+                                showInDialog: true,
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        vi.mocked(getSettingsSchema).mockReturnValue(SETTINGS_SCHEMA);
+    });
+    afterEach(() => {
+        TEST_ONLY.clearFlattenedSchema();
+        vi.clearAllMocks();
+        vi.resetAllMocks();
+    });
     describe('Schema Utilities', () => {
         describe('getSettingsByCategory', () => {
             it('should group settings by category', () => {
                 const categories = getSettingsByCategory();
-                expect(categories).toHaveProperty('General');
-                expect(categories).toHaveProperty('UI');
+                expect(categories).toHaveProperty('Advanced');
+                expect(categories).toHaveProperty('Basic');
             });
             it('should include key property in grouped settings', () => {
                 const categories = getSettingsByCategory();
@@ -28,9 +154,9 @@ describe('SettingsUtils', () => {
         });
         describe('getSettingDefinition', () => {
             it('should return definition for valid setting', () => {
-                const definition = getSettingDefinition('ui.showMemoryUsage');
+                const definition = getSettingDefinition('ui.theme');
                 expect(definition).toBeDefined();
-                expect(definition?.label).toBe('Show Memory Usage');
+                expect(definition?.label).toBe('Theme');
             });
             it('should return undefined for invalid setting', () => {
                 const definition = getSettingDefinition('invalidSetting');
@@ -39,12 +165,10 @@ describe('SettingsUtils', () => {
         });
         describe('requiresRestart', () => {
             it('should return true for settings that require restart', () => {
-                expect(requiresRestart('advanced.autoConfigureMemory')).toBe(true);
-                expect(requiresRestart('general.checkpointing.enabled')).toBe(true);
+                expect(requiresRestart('ui.requiresRestart')).toBe(true);
             });
             it('should return false for settings that do not require restart', () => {
-                expect(requiresRestart('ui.showMemoryUsage')).toBe(false);
-                expect(requiresRestart('ui.hideTips')).toBe(false);
+                expect(requiresRestart('ui.theme')).toBe(false);
             });
             it('should return false for invalid settings', () => {
                 expect(requiresRestart('invalidSetting')).toBe(false);
@@ -52,8 +176,8 @@ describe('SettingsUtils', () => {
         });
         describe('getDefaultValue', () => {
             it('should return correct default values', () => {
-                expect(getDefaultValue('ui.showMemoryUsage')).toBe(false);
-                expect(getDefaultValue('context.fileFiltering.enableRecursiveFileSearch')).toBe(true);
+                expect(getDefaultValue('test')).toBe('hello');
+                expect(getDefaultValue('ui.requiresRestart')).toBe(false);
             });
             it('should return undefined for invalid settings', () => {
                 expect(getDefaultValue('invalidSetting')).toBeUndefined();
@@ -62,43 +186,46 @@ describe('SettingsUtils', () => {
         describe('getRestartRequiredSettings', () => {
             it('should return all settings that require restart', () => {
                 const restartSettings = getRestartRequiredSettings();
-                expect(restartSettings).toContain('advanced.autoConfigureMemory');
-                expect(restartSettings).toContain('general.checkpointing.enabled');
-                expect(restartSettings).not.toContain('ui.showMemoryUsage');
+                expect(restartSettings).toContain('mcpServers');
+                expect(restartSettings).toContain('ui.requiresRestart');
             });
         });
         describe('getEffectiveValue', () => {
             it('should return value from settings when set', () => {
-                const settings = { ui: { showMemoryUsage: true } };
-                const mergedSettings = { ui: { showMemoryUsage: false } };
-                const value = getEffectiveValue('ui.showMemoryUsage', settings, mergedSettings);
+                const settings = makeMockSettings({ ui: { requiresRestart: true } });
+                const mergedSettings = makeMockSettings({
+                    ui: { requiresRestart: false },
+                });
+                const value = getEffectiveValue('ui.requiresRestart', settings, mergedSettings);
                 expect(value).toBe(true);
             });
             it('should return value from merged settings when not set in current scope', () => {
-                const settings = {};
-                const mergedSettings = { ui: { showMemoryUsage: true } };
-                const value = getEffectiveValue('ui.showMemoryUsage', settings, mergedSettings);
+                const settings = makeMockSettings({});
+                const mergedSettings = makeMockSettings({
+                    ui: { requiresRestart: true },
+                });
+                const value = getEffectiveValue('ui.requiresRestart', settings, mergedSettings);
                 expect(value).toBe(true);
             });
             it('should return default value when not set anywhere', () => {
-                const settings = {};
-                const mergedSettings = {};
-                const value = getEffectiveValue('ui.showMemoryUsage', settings, mergedSettings);
+                const settings = makeMockSettings({});
+                const mergedSettings = makeMockSettings({});
+                const value = getEffectiveValue('ui.requiresRestart', settings, mergedSettings);
                 expect(value).toBe(false); // default value
             });
             it('should handle nested settings correctly', () => {
-                const settings = {
+                const settings = makeMockSettings({
                     ui: { accessibility: { disableLoadingPhrases: true } },
-                };
-                const mergedSettings = {
+                });
+                const mergedSettings = makeMockSettings({
                     ui: { accessibility: { disableLoadingPhrases: false } },
-                };
+                });
                 const value = getEffectiveValue('ui.accessibility.disableLoadingPhrases', settings, mergedSettings);
                 expect(value).toBe(true);
             });
             it('should return undefined for invalid settings', () => {
-                const settings = {};
-                const mergedSettings = {};
+                const settings = makeMockSettings({});
+                const mergedSettings = makeMockSettings({});
                 const value = getEffectiveValue('invalidSetting', settings, mergedSettings);
                 expect(value).toBeUndefined();
             });
@@ -106,9 +233,8 @@ describe('SettingsUtils', () => {
         describe('getAllSettingKeys', () => {
             it('should return all setting keys', () => {
                 const keys = getAllSettingKeys();
-                expect(keys).toContain('ui.showMemoryUsage');
+                expect(keys).toContain('test');
                 expect(keys).toContain('ui.accessibility.disableLoadingPhrases');
-                expect(keys).toContain('general.checkpointing.enabled');
             });
         });
         describe('getSettingsByType', () => {
@@ -131,7 +257,7 @@ describe('SettingsUtils', () => {
         });
         describe('isValidSettingKey', () => {
             it('should return true for valid setting keys', () => {
-                expect(isValidSettingKey('ui.showMemoryUsage')).toBe(true);
+                expect(isValidSettingKey('ui.requiresRestart')).toBe(true);
                 expect(isValidSettingKey('ui.accessibility.disableLoadingPhrases')).toBe(true);
             });
             it('should return false for invalid setting keys', () => {
@@ -141,7 +267,7 @@ describe('SettingsUtils', () => {
         });
         describe('getSettingCategory', () => {
             it('should return correct category for valid settings', () => {
-                expect(getSettingCategory('ui.showMemoryUsage')).toBe('UI');
+                expect(getSettingCategory('ui.requiresRestart')).toBe('UI');
                 expect(getSettingCategory('ui.accessibility.disableLoadingPhrases')).toBe('UI');
             });
             it('should return undefined for invalid settings', () => {
@@ -150,17 +276,12 @@ describe('SettingsUtils', () => {
         });
         describe('shouldShowInDialog', () => {
             it('should return true for settings marked to show in dialog', () => {
-                expect(shouldShowInDialog('ui.showMemoryUsage')).toBe(true);
+                expect(shouldShowInDialog('ui.requiresRestart')).toBe(true);
                 expect(shouldShowInDialog('general.vimMode')).toBe(true);
                 expect(shouldShowInDialog('ui.hideWindowTitle')).toBe(true);
-                expect(shouldShowInDialog('privacy.usageStatisticsEnabled')).toBe(false);
             });
             it('should return false for settings marked to hide from dialog', () => {
-                expect(shouldShowInDialog('security.auth.selectedType')).toBe(false);
-                expect(shouldShowInDialog('tools.core')).toBe(false);
-                expect(shouldShowInDialog('ui.customThemes')).toBe(false);
-                expect(shouldShowInDialog('ui.theme')).toBe(false); // Changed to false
-                expect(shouldShowInDialog('general.preferredEditor')).toBe(false); // Changed to false
+                expect(shouldShowInDialog('ui.theme')).toBe(false);
             });
             it('should return true for invalid settings (default behavior)', () => {
                 expect(shouldShowInDialog('invalidSetting')).toBe(true);
@@ -173,9 +294,8 @@ describe('SettingsUtils', () => {
                 expect(categories['UI']).toBeDefined();
                 const uiSettings = categories['UI'];
                 const uiKeys = uiSettings.map((s) => s.key);
-                expect(uiKeys).toContain('ui.showMemoryUsage');
-                expect(uiKeys).toContain('ui.hideWindowTitle');
-                expect(uiKeys).not.toContain('ui.customThemes'); // This is marked false
+                expect(uiKeys).toContain('ui.requiresRestart');
+                expect(uiKeys).toContain('ui.accessibility.disableLoadingPhrases');
                 expect(uiKeys).not.toContain('ui.theme'); // This is now marked false
             });
             it('should not include Advanced category settings', () => {
@@ -187,13 +307,8 @@ describe('SettingsUtils', () => {
                 const categories = getDialogSettingsByCategory();
                 const allSettings = Object.values(categories).flat();
                 const allKeys = allSettings.map((s) => s.key);
-                expect(allKeys).toContain('general.vimMode');
-                expect(allKeys).toContain('ide.enabled');
-                expect(allKeys).toContain('general.disableAutoUpdate');
-                expect(allKeys).toContain('ui.showMemoryUsage');
-                expect(allKeys).not.toContain('privacy.usageStatisticsEnabled');
-                expect(allKeys).not.toContain('security.auth.selectedType');
-                expect(allKeys).not.toContain('tools.core');
+                expect(allKeys).toContain('test');
+                expect(allKeys).toContain('ui.requiresRestart');
                 expect(allKeys).not.toContain('ui.theme'); // Now hidden
                 expect(allKeys).not.toContain('general.preferredEditor'); // Now hidden
             });
@@ -202,9 +317,8 @@ describe('SettingsUtils', () => {
             it('should return only boolean dialog settings', () => {
                 const booleanSettings = getDialogSettingsByType('boolean');
                 const keys = booleanSettings.map((s) => s.key);
-                expect(keys).toContain('ui.showMemoryUsage');
-                expect(keys).toContain('general.vimMode');
-                expect(keys).toContain('ui.hideWindowTitle');
+                expect(keys).toContain('ui.requiresRestart');
+                expect(keys).toContain('ui.accessibility.disableLoadingPhrases');
                 expect(keys).not.toContain('privacy.usageStatisticsEnabled');
                 expect(keys).not.toContain('security.auth.selectedType'); // Advanced setting
                 expect(keys).not.toContain('security.auth.useExternal'); // Advanced setting
@@ -216,32 +330,23 @@ describe('SettingsUtils', () => {
                 expect(keys).not.toContain('ui.theme'); // Now marked false
                 expect(keys).not.toContain('general.preferredEditor'); // Now marked false
                 expect(keys).not.toContain('security.auth.selectedType'); // Advanced setting
-                // Most string settings are now hidden, so let's just check they exclude advanced ones
-                expect(keys.every((key) => !key.startsWith('tool'))).toBe(true); // No tool-related settings
+                // Check that user-facing tool settings are included
+                expect(keys).toContain('tools.shell.pager');
+                // Check that advanced/hidden tool settings are excluded
+                expect(keys).not.toContain('tools.discoveryCommand');
+                expect(keys).not.toContain('tools.callCommand');
+                expect(keys.every((key) => !key.startsWith('advanced.'))).toBe(true);
             });
         });
         describe('getDialogSettingKeys', () => {
             it('should return only settings marked for dialog display', () => {
                 const dialogKeys = getDialogSettingKeys();
                 // Should include settings marked for dialog
-                expect(dialogKeys).toContain('ui.showMemoryUsage');
-                expect(dialogKeys).toContain('general.vimMode');
-                expect(dialogKeys).toContain('ui.hideWindowTitle');
-                expect(dialogKeys).not.toContain('privacy.usageStatisticsEnabled');
-                expect(dialogKeys).toContain('ide.enabled');
-                expect(dialogKeys).toContain('general.disableAutoUpdate');
+                expect(dialogKeys).toContain('ui.requiresRestart');
                 // Should include nested settings marked for dialog
-                expect(dialogKeys).toContain('context.fileFiltering.respectGitIgnore');
-                expect(dialogKeys).toContain('context.fileFiltering.respectGeminiIgnore');
-                expect(dialogKeys).toContain('context.fileFiltering.enableRecursiveFileSearch');
+                expect(dialogKeys).toContain('ui.accessibility.disableLoadingPhrases');
                 // Should NOT include settings marked as hidden
                 expect(dialogKeys).not.toContain('ui.theme'); // Hidden
-                expect(dialogKeys).not.toContain('ui.customThemes'); // Hidden
-                expect(dialogKeys).not.toContain('general.preferredEditor'); // Hidden
-                expect(dialogKeys).not.toContain('security.auth.selectedType'); // Advanced
-                expect(dialogKeys).not.toContain('tools.core'); // Advanced
-                expect(dialogKeys).not.toContain('mcpServers'); // Advanced
-                expect(dialogKeys).not.toContain('telemetry'); // Advanced
             });
             it('should return fewer keys than getAllSettingKeys', () => {
                 const allKeys = getAllSettingKeys();
@@ -250,10 +355,43 @@ describe('SettingsUtils', () => {
                 expect(dialogKeys.length).toBeGreaterThan(0);
             });
             it('should handle nested settings display correctly', () => {
+                vi.mocked(getSettingsSchema).mockReturnValue({
+                    context: {
+                        type: 'object',
+                        label: 'Context',
+                        category: 'Context',
+                        requiresRestart: false,
+                        default: {},
+                        description: 'Settings for managing context provided to the model.',
+                        showInDialog: false,
+                        properties: {
+                            fileFiltering: {
+                                type: 'object',
+                                label: 'File Filtering',
+                                category: 'Context',
+                                requiresRestart: true,
+                                default: {},
+                                description: 'Settings for git-aware file filtering.',
+                                showInDialog: false,
+                                properties: {
+                                    respectGitIgnore: {
+                                        type: 'boolean',
+                                        label: 'Respect .gitignore',
+                                        category: 'Context',
+                                        requiresRestart: true,
+                                        default: true,
+                                        description: 'Respect .gitignore files when searching',
+                                        showInDialog: true,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
                 // Test the specific issue with fileFiltering.respectGitIgnore
                 const key = 'context.fileFiltering.respectGitIgnore';
-                const initialSettings = {};
-                const pendingSettings = {};
+                const initialSettings = makeMockSettings({});
+                const pendingSettings = makeMockSettings({});
                 // Set the nested setting to true
                 const updatedPendingSettings = setPendingSettingValue(key, true, pendingSettings);
                 // Check if the setting exists in pending settings
@@ -275,79 +413,83 @@ describe('SettingsUtils', () => {
     describe('Business Logic Utilities', () => {
         describe('getSettingValue', () => {
             it('should return value from settings when set', () => {
-                const settings = { ui: { showMemoryUsage: true } };
-                const mergedSettings = { ui: { showMemoryUsage: false } };
-                const value = getSettingValue('ui.showMemoryUsage', settings, mergedSettings);
+                const settings = makeMockSettings({ ui: { requiresRestart: true } });
+                const mergedSettings = makeMockSettings({
+                    ui: { requiresRestart: false },
+                });
+                const value = getSettingValue('ui.requiresRestart', settings, mergedSettings);
                 expect(value).toBe(true);
             });
             it('should return value from merged settings when not set in current scope', () => {
-                const settings = {};
-                const mergedSettings = { ui: { showMemoryUsage: true } };
-                const value = getSettingValue('ui.showMemoryUsage', settings, mergedSettings);
+                const settings = makeMockSettings({});
+                const mergedSettings = makeMockSettings({
+                    ui: { requiresRestart: true },
+                });
+                const value = getSettingValue('ui.requiresRestart', settings, mergedSettings);
                 expect(value).toBe(true);
             });
             it('should return default value for invalid setting', () => {
-                const settings = {};
-                const mergedSettings = {};
+                const settings = makeMockSettings({});
+                const mergedSettings = makeMockSettings({});
                 const value = getSettingValue('invalidSetting', settings, mergedSettings);
                 expect(value).toBe(false); // Default fallback
             });
         });
         describe('isSettingModified', () => {
             it('should return true when value differs from default', () => {
-                expect(isSettingModified('ui.showMemoryUsage', true)).toBe(true);
-                expect(isSettingModified('context.fileFiltering.enableRecursiveFileSearch', false)).toBe(true);
+                expect(isSettingModified('ui.requiresRestart', true)).toBe(true);
+                expect(isSettingModified('ui.accessibility.disableLoadingPhrases', true)).toBe(true);
             });
             it('should return false when value matches default', () => {
-                expect(isSettingModified('ui.showMemoryUsage', false)).toBe(false);
-                expect(isSettingModified('context.fileFiltering.enableRecursiveFileSearch', true)).toBe(false);
+                expect(isSettingModified('ui.requiresRestart', false)).toBe(false);
+                expect(isSettingModified('ui.accessibility.disableLoadingPhrases', false)).toBe(false);
             });
         });
         describe('settingExistsInScope', () => {
             it('should return true for top-level settings that exist', () => {
-                const settings = { ui: { showMemoryUsage: true } };
-                expect(settingExistsInScope('ui.showMemoryUsage', settings)).toBe(true);
+                const settings = makeMockSettings({ ui: { requiresRestart: true } });
+                expect(settingExistsInScope('ui.requiresRestart', settings)).toBe(true);
             });
             it('should return false for top-level settings that do not exist', () => {
-                const settings = {};
-                expect(settingExistsInScope('ui.showMemoryUsage', settings)).toBe(false);
+                const settings = makeMockSettings({});
+                expect(settingExistsInScope('ui.requiresRestart', settings)).toBe(false);
             });
             it('should return true for nested settings that exist', () => {
-                const settings = {
+                const settings = makeMockSettings({
                     ui: { accessibility: { disableLoadingPhrases: true } },
-                };
+                });
                 expect(settingExistsInScope('ui.accessibility.disableLoadingPhrases', settings)).toBe(true);
             });
             it('should return false for nested settings that do not exist', () => {
-                const settings = {};
+                const settings = makeMockSettings({});
                 expect(settingExistsInScope('ui.accessibility.disableLoadingPhrases', settings)).toBe(false);
             });
             it('should return false when parent exists but child does not', () => {
-                const settings = { ui: { accessibility: {} } };
+                const settings = makeMockSettings({ ui: { accessibility: {} } });
                 expect(settingExistsInScope('ui.accessibility.disableLoadingPhrases', settings)).toBe(false);
             });
         });
         describe('setPendingSettingValue', () => {
             it('should set top-level setting value', () => {
-                const pendingSettings = {};
-                const result = setPendingSettingValue('ui.showMemoryUsage', true, pendingSettings);
-                expect(result.ui?.showMemoryUsage).toBe(true);
+                const pendingSettings = makeMockSettings({});
+                const result = setPendingSettingValue('ui.hideWindowTitle', true, pendingSettings);
+                expect(result.ui?.hideWindowTitle).toBe(true);
             });
             it('should set nested setting value', () => {
-                const pendingSettings = {};
+                const pendingSettings = makeMockSettings({});
                 const result = setPendingSettingValue('ui.accessibility.disableLoadingPhrases', true, pendingSettings);
                 expect(result.ui?.accessibility?.disableLoadingPhrases).toBe(true);
             });
             it('should preserve existing nested settings', () => {
-                const pendingSettings = {
+                const pendingSettings = makeMockSettings({
                     ui: { accessibility: { disableLoadingPhrases: false } },
-                };
+                });
                 const result = setPendingSettingValue('ui.accessibility.disableLoadingPhrases', true, pendingSettings);
                 expect(result.ui?.accessibility?.disableLoadingPhrases).toBe(true);
             });
             it('should not mutate original settings', () => {
-                const pendingSettings = {};
-                setPendingSettingValue('ui.showMemoryUsage', true, pendingSettings);
+                const pendingSettings = makeMockSettings({});
+                setPendingSettingValue('ui.requiresRestart', true, pendingSettings);
                 expect(pendingSettings).toEqual({});
             });
         });
@@ -355,15 +497,12 @@ describe('SettingsUtils', () => {
             it('should return true when modified settings require restart', () => {
                 const modifiedSettings = new Set([
                     'advanced.autoConfigureMemory',
-                    'ui.showMemoryUsage',
+                    'ui.requiresRestart',
                 ]);
                 expect(hasRestartRequiredSettings(modifiedSettings)).toBe(true);
             });
             it('should return false when no modified settings require restart', () => {
-                const modifiedSettings = new Set([
-                    'ui.showMemoryUsage',
-                    'ui.hideTips',
-                ]);
+                const modifiedSettings = new Set(['test']);
                 expect(hasRestartRequiredSettings(modifiedSettings)).toBe(false);
             });
             it('should return false for empty set', () => {
@@ -374,18 +513,16 @@ describe('SettingsUtils', () => {
         describe('getRestartRequiredFromModified', () => {
             it('should return only settings that require restart', () => {
                 const modifiedSettings = new Set([
-                    'advanced.autoConfigureMemory',
-                    'ui.showMemoryUsage',
-                    'general.checkpointing.enabled',
+                    'ui.requiresRestart',
+                    'test',
                 ]);
                 const result = getRestartRequiredFromModified(modifiedSettings);
-                expect(result).toContain('advanced.autoConfigureMemory');
-                expect(result).toContain('general.checkpointing.enabled');
-                expect(result).not.toContain('ui.showMemoryUsage');
+                expect(result).toContain('ui.requiresRestart');
+                expect(result).not.toContain('test');
             });
             it('should return empty array when no settings require restart', () => {
                 const modifiedSettings = new Set([
-                    'showMemoryUsage',
+                    'requiresRestart',
                     'hideTips',
                 ]);
                 const result = getRestartRequiredFromModified(modifiedSettings);
@@ -393,116 +530,276 @@ describe('SettingsUtils', () => {
             });
         });
         describe('getDisplayValue', () => {
+            describe('enum behavior', () => {
+                let StringEnum;
+                (function (StringEnum) {
+                    StringEnum["FOO"] = "foo";
+                    StringEnum["BAR"] = "bar";
+                    StringEnum["BAZ"] = "baz";
+                })(StringEnum || (StringEnum = {}));
+                let NumberEnum;
+                (function (NumberEnum) {
+                    NumberEnum[NumberEnum["ONE"] = 1] = "ONE";
+                    NumberEnum[NumberEnum["TWO"] = 2] = "TWO";
+                    NumberEnum[NumberEnum["THREE"] = 3] = "THREE";
+                })(NumberEnum || (NumberEnum = {}));
+                const SETTING = {
+                    type: 'enum',
+                    label: 'Theme',
+                    options: [
+                        {
+                            value: StringEnum.FOO,
+                            label: 'Foo',
+                        },
+                        {
+                            value: StringEnum.BAR,
+                            label: 'Bar',
+                        },
+                        {
+                            value: StringEnum.BAZ,
+                            label: 'Baz',
+                        },
+                    ],
+                    category: 'UI',
+                    requiresRestart: false,
+                    default: StringEnum.BAR,
+                    description: 'The color theme for the UI.',
+                    showInDialog: false,
+                };
+                it('handles display of number-based enums', () => {
+                    vi.mocked(getSettingsSchema).mockReturnValue({
+                        ui: {
+                            properties: {
+                                theme: {
+                                    ...SETTING,
+                                    options: [
+                                        {
+                                            value: NumberEnum.ONE,
+                                            label: 'One',
+                                        },
+                                        {
+                                            value: NumberEnum.TWO,
+                                            label: 'Two',
+                                        },
+                                        {
+                                            value: NumberEnum.THREE,
+                                            label: 'Three',
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    });
+                    const settings = makeMockSettings({
+                        ui: { theme: NumberEnum.THREE },
+                    });
+                    const mergedSettings = makeMockSettings({
+                        ui: { theme: NumberEnum.THREE },
+                    });
+                    const modifiedSettings = new Set();
+                    const result = getDisplayValue('ui.theme', settings, mergedSettings, modifiedSettings);
+                    expect(result).toBe('Three*');
+                });
+                it('handles default values for number-based enums', () => {
+                    vi.mocked(getSettingsSchema).mockReturnValue({
+                        ui: {
+                            properties: {
+                                theme: {
+                                    ...SETTING,
+                                    default: NumberEnum.THREE,
+                                    options: [
+                                        {
+                                            value: NumberEnum.ONE,
+                                            label: 'One',
+                                        },
+                                        {
+                                            value: NumberEnum.TWO,
+                                            label: 'Two',
+                                        },
+                                        {
+                                            value: NumberEnum.THREE,
+                                            label: 'Three',
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    });
+                    const modifiedSettings = new Set();
+                    const result = getDisplayValue('ui.theme', makeMockSettings({}), makeMockSettings({}), modifiedSettings);
+                    expect(result).toBe('Three');
+                });
+                it('shows the enum display value', () => {
+                    vi.mocked(getSettingsSchema).mockReturnValue({
+                        ui: { properties: { theme: { ...SETTING } } },
+                    });
+                    const settings = makeMockSettings({ ui: { theme: StringEnum.BAR } });
+                    const mergedSettings = makeMockSettings({
+                        ui: { theme: StringEnum.BAR },
+                    });
+                    const modifiedSettings = new Set();
+                    const result = getDisplayValue('ui.theme', settings, mergedSettings, modifiedSettings);
+                    expect(result).toBe('Bar*');
+                });
+                it('passes through unknown values verbatim', () => {
+                    vi.mocked(getSettingsSchema).mockReturnValue({
+                        ui: {
+                            properties: {
+                                theme: { ...SETTING },
+                            },
+                        },
+                    });
+                    const settings = makeMockSettings({ ui: { theme: 'xyz' } });
+                    const mergedSettings = makeMockSettings({ ui: { theme: 'xyz' } });
+                    const modifiedSettings = new Set();
+                    const result = getDisplayValue('ui.theme', settings, mergedSettings, modifiedSettings);
+                    expect(result).toBe('xyz*');
+                });
+                it('shows the default value for string enums', () => {
+                    vi.mocked(getSettingsSchema).mockReturnValue({
+                        ui: {
+                            properties: {
+                                theme: { ...SETTING, default: StringEnum.BAR },
+                            },
+                        },
+                    });
+                    const modifiedSettings = new Set();
+                    const result = getDisplayValue('ui.theme', makeMockSettings({}), makeMockSettings({}), modifiedSettings);
+                    expect(result).toBe('Bar');
+                });
+            });
             it('should show value without * when setting matches default', () => {
-                const settings = { ui: { showMemoryUsage: false } }; // false matches default, so no *
-                const mergedSettings = { ui: { showMemoryUsage: false } };
+                const settings = makeMockSettings({
+                    ui: { requiresRestart: false },
+                }); // false matches default, so no *
+                const mergedSettings = makeMockSettings({
+                    ui: { requiresRestart: false },
+                });
                 const modifiedSettings = new Set();
-                const result = getDisplayValue('ui.showMemoryUsage', settings, mergedSettings, modifiedSettings);
+                const result = getDisplayValue('ui.requiresRestart', settings, mergedSettings, modifiedSettings);
                 expect(result).toBe('false*');
             });
             it('should show default value when setting is not in scope', () => {
-                const settings = {}; // no setting in scope
-                const mergedSettings = { ui: { showMemoryUsage: false } };
+                const settings = makeMockSettings({}); // no setting in scope
+                const mergedSettings = makeMockSettings({
+                    ui: { requiresRestart: false },
+                });
                 const modifiedSettings = new Set();
-                const result = getDisplayValue('ui.showMemoryUsage', settings, mergedSettings, modifiedSettings);
+                const result = getDisplayValue('ui.requiresRestart', settings, mergedSettings, modifiedSettings);
                 expect(result).toBe('false'); // shows default value
             });
             it('should show value with * when changed from default', () => {
-                const settings = { ui: { showMemoryUsage: true } }; // true is different from default (false)
-                const mergedSettings = { ui: { showMemoryUsage: true } };
+                const settings = makeMockSettings({ ui: { requiresRestart: true } }); // true is different from default (false)
+                const mergedSettings = makeMockSettings({
+                    ui: { requiresRestart: true },
+                });
                 const modifiedSettings = new Set();
-                const result = getDisplayValue('ui.showMemoryUsage', settings, mergedSettings, modifiedSettings);
+                const result = getDisplayValue('ui.requiresRestart', settings, mergedSettings, modifiedSettings);
                 expect(result).toBe('true*');
             });
             it('should show default value without * when setting does not exist in scope', () => {
-                const settings = {}; // setting doesn't exist in scope, show default
-                const mergedSettings = { ui: { showMemoryUsage: false } };
+                const settings = makeMockSettings({}); // setting doesn't exist in scope, show default
+                const mergedSettings = makeMockSettings({
+                    ui: { requiresRestart: false },
+                });
                 const modifiedSettings = new Set();
-                const result = getDisplayValue('ui.showMemoryUsage', settings, mergedSettings, modifiedSettings);
+                const result = getDisplayValue('ui.requiresRestart', settings, mergedSettings, modifiedSettings);
                 expect(result).toBe('false'); // default value (false) without *
             });
             it('should show value with * when user changes from default', () => {
-                const settings = {}; // setting doesn't exist in scope originally
-                const mergedSettings = { ui: { showMemoryUsage: false } };
-                const modifiedSettings = new Set(['ui.showMemoryUsage']);
-                const pendingSettings = { ui: { showMemoryUsage: true } }; // user changed to true
-                const result = getDisplayValue('ui.showMemoryUsage', settings, mergedSettings, modifiedSettings, pendingSettings);
+                const settings = makeMockSettings({}); // setting doesn't exist in scope originally
+                const mergedSettings = makeMockSettings({
+                    ui: { requiresRestart: false },
+                });
+                const modifiedSettings = new Set(['ui.requiresRestart']);
+                const pendingSettings = makeMockSettings({
+                    ui: { requiresRestart: true },
+                }); // user changed to true
+                const result = getDisplayValue('ui.requiresRestart', settings, mergedSettings, modifiedSettings, pendingSettings);
                 expect(result).toBe('true*'); // changed from default (false) to true
             });
         });
         describe('isDefaultValue', () => {
             it('should return true when setting does not exist in scope', () => {
-                const settings = {}; // setting doesn't exist
-                const result = isDefaultValue('ui.showMemoryUsage', settings);
+                const settings = makeMockSettings({}); // setting doesn't exist
+                const result = isDefaultValue('ui.requiresRestart', settings);
                 expect(result).toBe(true);
             });
             it('should return false when setting exists in scope', () => {
-                const settings = { ui: { showMemoryUsage: true } }; // setting exists
-                const result = isDefaultValue('ui.showMemoryUsage', settings);
+                const settings = makeMockSettings({ ui: { requiresRestart: true } }); // setting exists
+                const result = isDefaultValue('ui.requiresRestart', settings);
                 expect(result).toBe(false);
             });
             it('should return true when nested setting does not exist in scope', () => {
-                const settings = {}; // nested setting doesn't exist
+                const settings = makeMockSettings({}); // nested setting doesn't exist
                 const result = isDefaultValue('ui.accessibility.disableLoadingPhrases', settings);
                 expect(result).toBe(true);
             });
             it('should return false when nested setting exists in scope', () => {
-                const settings = {
+                const settings = makeMockSettings({
                     ui: { accessibility: { disableLoadingPhrases: true } },
-                }; // nested setting exists
+                }); // nested setting exists
                 const result = isDefaultValue('ui.accessibility.disableLoadingPhrases', settings);
                 expect(result).toBe(false);
             });
         });
         describe('isValueInherited', () => {
             it('should return false for top-level settings that exist in scope', () => {
-                const settings = { ui: { showMemoryUsage: true } };
-                const mergedSettings = { ui: { showMemoryUsage: true } };
-                const result = isValueInherited('ui.showMemoryUsage', settings, mergedSettings);
+                const settings = makeMockSettings({ ui: { requiresRestart: true } });
+                const mergedSettings = makeMockSettings({
+                    ui: { requiresRestart: true },
+                });
+                const result = isValueInherited('ui.requiresRestart', settings, mergedSettings);
                 expect(result).toBe(false);
             });
             it('should return true for top-level settings that do not exist in scope', () => {
-                const settings = {};
-                const mergedSettings = { ui: { showMemoryUsage: true } };
-                const result = isValueInherited('ui.showMemoryUsage', settings, mergedSettings);
+                const settings = makeMockSettings({});
+                const mergedSettings = makeMockSettings({
+                    ui: { requiresRestart: true },
+                });
+                const result = isValueInherited('ui.requiresRestart', settings, mergedSettings);
                 expect(result).toBe(true);
             });
             it('should return false for nested settings that exist in scope', () => {
-                const settings = {
+                const settings = makeMockSettings({
                     ui: { accessibility: { disableLoadingPhrases: true } },
-                };
-                const mergedSettings = {
+                });
+                const mergedSettings = makeMockSettings({
                     ui: { accessibility: { disableLoadingPhrases: true } },
-                };
+                });
                 const result = isValueInherited('ui.accessibility.disableLoadingPhrases', settings, mergedSettings);
                 expect(result).toBe(false);
             });
             it('should return true for nested settings that do not exist in scope', () => {
-                const settings = {};
-                const mergedSettings = {
+                const settings = makeMockSettings({});
+                const mergedSettings = makeMockSettings({
                     ui: { accessibility: { disableLoadingPhrases: true } },
-                };
+                });
                 const result = isValueInherited('ui.accessibility.disableLoadingPhrases', settings, mergedSettings);
                 expect(result).toBe(true);
             });
         });
         describe('getEffectiveDisplayValue', () => {
             it('should return value from settings when available', () => {
-                const settings = { ui: { showMemoryUsage: true } };
-                const mergedSettings = { ui: { showMemoryUsage: false } };
-                const result = getEffectiveDisplayValue('ui.showMemoryUsage', settings, mergedSettings);
+                const settings = makeMockSettings({ ui: { requiresRestart: true } });
+                const mergedSettings = makeMockSettings({
+                    ui: { requiresRestart: false },
+                });
+                const result = getEffectiveDisplayValue('ui.requiresRestart', settings, mergedSettings);
                 expect(result).toBe(true);
             });
             it('should return value from merged settings when not in scope', () => {
-                const settings = {};
-                const mergedSettings = { ui: { showMemoryUsage: true } };
-                const result = getEffectiveDisplayValue('ui.showMemoryUsage', settings, mergedSettings);
+                const settings = makeMockSettings({});
+                const mergedSettings = makeMockSettings({
+                    ui: { requiresRestart: true },
+                });
+                const result = getEffectiveDisplayValue('ui.requiresRestart', settings, mergedSettings);
                 expect(result).toBe(true);
             });
             it('should return default value for undefined values', () => {
-                const settings = {};
-                const mergedSettings = {};
-                const result = getEffectiveDisplayValue('ui.showMemoryUsage', settings, mergedSettings);
+                const settings = makeMockSettings({});
+                const mergedSettings = makeMockSettings({});
+                const result = getEffectiveDisplayValue('ui.requiresRestart', settings, mergedSettings);
                 expect(result).toBe(false); // Default value
             });
         });