@umsai/ums-code 0.0.14-v2 → 0.3.0-v1

package/dist/src/config/settings.js

@@ -7,65 +7,111 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { homedir, platform } from 'node:os';
 import * as dotenv from 'dotenv';
-import { GEMINI_CONFIG_DIR as GEMINI_DIR, getErrorMessage, Storage, } from '@umsai/ums-code-core';
+import process from 'node:process';
+import { FatalConfigError, QWEN_DIR, getErrorMessage, Storage, } from '@umsai/ums-code-core';
 import stripJsonComments from 'strip-json-comments';
 import { DefaultLight } from '../ui/themes/default-light.js';
 import { DefaultDark } from '../ui/themes/default.js';
 import { isWorkspaceTrusted } from './trustedFolders.js';
-import { mergeWith } from 'lodash-es';
+import { getSettingsSchema, } from './settingsSchema.js';
+import { resolveEnvVarsInObject } from '../utils/envVarResolver.js';
+import { customDeepMerge } from '../utils/deepMerge.js';
+import { updateSettingsFilePreservingFormat } from '../utils/commentJson.js';
+import { disableExtension } from './extension.js';
+function getMergeStrategyForPath(path) {
+    let current = undefined;
+    let currentSchema = getSettingsSchema();
+    for (const key of path) {
+        if (!currentSchema || !currentSchema[key]) {
+            return undefined;
+        }
+        current = currentSchema[key];
+        currentSchema = current.properties;
+    }
+    return current?.mergeStrategy;
+}
 export const SETTINGS_DIRECTORY_NAME = '.ums';
 export const USER_SETTINGS_PATH = Storage.getGlobalSettingsPath();
 export const USER_SETTINGS_DIR = path.dirname(USER_SETTINGS_PATH);
 export const DEFAULT_EXCLUDED_ENV_VARS = ['DEBUG', 'DEBUG_MODE'];
-const MIGRATE_V2_OVERWRITE = false;
+const MIGRATE_V2_OVERWRITE = true;
+// Settings version to track migration state
+export const SETTINGS_VERSION = 2;
+export const SETTINGS_VERSION_KEY = '$version';
 const MIGRATION_MAP = {
-    preferredEditor: 'general.preferredEditor',
-    vimMode: 'general.vimMode',
-    disableAutoUpdate: 'general.disableAutoUpdate',
-    disableUpdateNag: 'general.disableUpdateNag',
+    accessibility: 'ui.accessibility',
+    allowedTools: 'tools.allowed',
+    allowMCPServers: 'mcp.allowed',
+    autoAccept: 'tools.autoAccept',
+    autoConfigureMaxOldSpaceSize: 'advanced.autoConfigureMemory',
+    bugCommand: 'advanced.bugCommand',
+    chatCompression: 'model.chatCompression',
     checkpointing: 'general.checkpointing',
-    theme: 'ui.theme',
+    coreTools: 'tools.core',
+    contextFileName: 'context.fileName',
     customThemes: 'ui.customThemes',
+    customWittyPhrases: 'ui.customWittyPhrases',
+    debugKeystrokeLogging: 'general.debugKeystrokeLogging',
+    disableAutoUpdate: 'general.disableAutoUpdate',
+    disableUpdateNag: 'general.disableUpdateNag',
+    dnsResolutionOrder: 'advanced.dnsResolutionOrder',
+    enforcedAuthType: 'security.auth.enforcedType',
+    excludeTools: 'tools.exclude',
+    excludeMCPServers: 'mcp.excluded',
+    excludedProjectEnvVars: 'advanced.excludedEnvVars',
+    extensionManagement: 'experimental.extensionManagement',
+    extensions: 'extensions',
+    fileFiltering: 'context.fileFiltering',
+    folderTrustFeature: 'security.folderTrust.featureEnabled',
+    folderTrust: 'security.folderTrust.enabled',
+    hasSeenIdeIntegrationNudge: 'ide.hasSeenNudge',
     hideWindowTitle: 'ui.hideWindowTitle',
+    showStatusInTitle: 'ui.showStatusInTitle',
     hideTips: 'ui.hideTips',
     hideBanner: 'ui.hideBanner',
     hideFooter: 'ui.hideFooter',
+    hideCWD: 'ui.footer.hideCWD',
+    hideSandboxStatus: 'ui.footer.hideSandboxStatus',
+    hideModelInfo: 'ui.footer.hideModelInfo',
+    hideContextSummary: 'ui.hideContextSummary',
     showMemoryUsage: 'ui.showMemoryUsage',
     showLineNumbers: 'ui.showLineNumbers',
-    accessibility: 'ui.accessibility',
+    showCitations: 'ui.showCitations',
     ideMode: 'ide.enabled',
-    hasSeenIdeIntegrationNudge: 'ide.hasSeenNudge',
-    usageStatisticsEnabled: 'privacy.usageStatisticsEnabled',
-    telemetry: 'telemetry',
-    model: 'model.name',
+    includeDirectories: 'context.includeDirectories',
+    loadMemoryFromIncludeDirectories: 'context.loadFromIncludeDirectories',
     maxSessionTurns: 'model.maxSessionTurns',
-    summarizeToolOutput: 'model.summarizeToolOutput',
-    chatCompression: 'model.chatCompression',
-    skipNextSpeakerCheck: 'model.skipNextSpeakerCheck',
-    contextFileName: 'context.fileName',
+    mcpServers: 'mcpServers',
+    mcpServerCommand: 'mcp.serverCommand',
     memoryImportFormat: 'context.importFormat',
     memoryDiscoveryMaxDirs: 'context.discoveryMaxDirs',
-    includeDirectories: 'context.includeDirectories',
-    loadMemoryFromIncludeDirectories: 'context.loadFromIncludeDirectories',
-    fileFiltering: 'context.fileFiltering',
+    model: 'model.name',
+    preferredEditor: 'general.preferredEditor',
     sandbox: 'tools.sandbox',
-    shouldUseNodePtyShell: 'tools.usePty',
-    allowedTools: 'tools.allowed',
-    coreTools: 'tools.core',
-    excludeTools: 'tools.exclude',
+    selectedAuthType: 'security.auth.selectedType',
+    shouldUseNodePtyShell: 'tools.shell.enableInteractiveShell',
+    shellPager: 'tools.shell.pager',
+    shellShowColor: 'tools.shell.showColor',
+    skipNextSpeakerCheck: 'model.skipNextSpeakerCheck',
+    summarizeToolOutput: 'model.summarizeToolOutput',
+    telemetry: 'telemetry',
+    theme: 'ui.theme',
     toolDiscoveryCommand: 'tools.discoveryCommand',
     toolCallCommand: 'tools.callCommand',
-    mcpServerCommand: 'mcp.serverCommand',
-    allowMCPServers: 'mcp.allowed',
-    excludeMCPServers: 'mcp.excluded',
-    folderTrustFeature: 'security.folderTrust.featureEnabled',
-    folderTrust: 'security.folderTrust.enabled',
-    selectedAuthType: 'security.auth.selectedType',
+    usageStatisticsEnabled: 'privacy.usageStatisticsEnabled',
     useExternalAuth: 'security.auth.useExternal',
-    autoConfigureMaxOldSpaceSize: 'advanced.autoConfigureMemory',
-    dnsResolutionOrder: 'advanced.dnsResolutionOrder',
-    excludedProjectEnvVars: 'advanced.excludedEnvVars',
-    bugCommand: 'advanced.bugCommand',
+    useRipgrep: 'tools.useRipgrep',
+    vimMode: 'general.vimMode',
+    enableWelcomeBack: 'ui.enableWelcomeBack',
+    approvalMode: 'tools.approvalMode',
+    sessionTokenLimit: 'model.sessionTokenLimit',
+    contentGenerator: 'model.generationConfig',
+    skipLoopDetection: 'model.skipLoopDetection',
+    skipStartupContext: 'model.skipStartupContext',
+    enableOpenAILogging: 'model.enableOpenAILogging',
+    tavilyApiKey: 'advanced.tavilyApiKey',
+    vlmSwitchMode: 'experimental.vlmSwitchMode',
+    visionModelPreview: 'experimental.visionModelPreview',
 };
 export function getSystemSettingsPath() {
     if (process.env['QWEN_CODE_SYSTEM_SETTINGS_PATH']) {
@@ -115,8 +161,31 @@ function setNestedProperty(obj, path, value) {
     }
     current[lastKey] = value;
 }
-function needsMigration(settings) {
-    return !('general' in settings);
+export function needsMigration(settings) {
+    // Check version field first - if present and matches current version, no migration needed
+    if (SETTINGS_VERSION_KEY in settings) {
+        const version = settings[SETTINGS_VERSION_KEY];
+        if (typeof version === 'number' && version >= SETTINGS_VERSION) {
+            return false;
+        }
+    }
+    // Fallback to legacy detection: A file needs migration if it contains any
+    // top-level key that is moved to a nested location in V2.
+    const hasV1Keys = Object.entries(MIGRATION_MAP).some(([v1Key, v2Path]) => {
+        if (v1Key === v2Path || !(v1Key in settings)) {
+            return false;
+        }
+        // If a key exists that is both a V1 key and a V2 container (like 'model'),
+        // we need to check the type. If it's an object, it's a V2 container and not
+        // a V1 key that needs migration.
+        if (KNOWN_V2_CONTAINERS.has(v1Key) &&
+            typeof settings[v1Key] === 'object' &&
+            settings[v1Key] !== null) {
+            return false;
+        }
+        return true;
+    });
+    return hasV1Keys;
 }
 function migrateSettingsToV2(flatSettings) {
     if (!needsMigration(flatSettings)) {
@@ -126,6 +195,18 @@ function migrateSettingsToV2(flatSettings) {
     const flatKeys = new Set(Object.keys(flatSettings));
     for (const [oldKey, newPath] of Object.entries(MIGRATION_MAP)) {
         if (flatKeys.has(oldKey)) {
+            // Safety check: If this key is a V2 container (like 'model') and it's
+            // already an object, it's likely already in V2 format. Skip migration
+            // to prevent double-nesting (e.g., model.name.name).
+            if (KNOWN_V2_CONTAINERS.has(oldKey) &&
+                typeof flatSettings[oldKey] === 'object' &&
+                flatSettings[oldKey] !== null &&
+                !Array.isArray(flatSettings[oldKey])) {
+                // This is already a V2 container, carry it over as-is
+                v2Settings[oldKey] = flatSettings[oldKey];
+                flatKeys.delete(oldKey);
+                continue;
+            }
             setNestedProperty(v2Settings, newPath, flatSettings[oldKey]);
             flatKeys.delete(oldKey);
         }
@@ -137,8 +218,23 @@ function migrateSettingsToV2(flatSettings) {
     }
     // Carry over any unrecognized keys
     for (const remainingKey of flatKeys) {
-        v2Settings[remainingKey] = flatSettings[remainingKey];
+        const existingValue = v2Settings[remainingKey];
+        const newValue = flatSettings[remainingKey];
+        if (typeof existingValue === 'object' &&
+            existingValue !== null &&
+            !Array.isArray(existingValue) &&
+            typeof newValue === 'object' &&
+            newValue !== null &&
+            !Array.isArray(newValue)) {
+            const pathAwareGetStrategy = (path) => getMergeStrategyForPath([remainingKey, ...path]);
+            v2Settings[remainingKey] = customDeepMerge(pathAwareGetStrategy, {}, newValue, existingValue);
+        }
+        else {
+            v2Settings[remainingKey] = newValue;
+        }
     }
+    // Set version field to indicate this is a V2 settings file
+    v2Settings[SETTINGS_VERSION_KEY] = SETTINGS_VERSION;
     return v2Settings;
 }
 function getNestedProperty(obj, path) {
@@ -172,6 +268,10 @@ export function migrateSettingsToV1(v2Settings) {
     }
     // Carry over any unrecognized keys
     for (const remainingKey of v2Keys) {
+        // Skip the version field - it's only for V2 format
+        if (remainingKey === SETTINGS_VERSION_KEY) {
+            continue;
+        }
         const value = v2Settings[remainingKey];
         if (value === undefined) {
             continue;
@@ -190,180 +290,21 @@ export function migrateSettingsToV1(v2Settings) {
 }
 function mergeSettings(system, systemDefaults, user, workspace, isTrusted) {
     const safeWorkspace = isTrusted ? workspace : {};
-    // folderTrust is not supported at workspace level.
-    const { security, ...restOfWorkspace } = safeWorkspace;
-    const safeWorkspaceWithoutFolderTrust = security
-        ? {
-            ...restOfWorkspace,
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            security: (({ folderTrust, ...rest }) => rest)(security),
-        }
-        : {
-            ...restOfWorkspace,
-            security: {},
-        };
     // Settings are merged with the following precedence (last one wins for
     // single values):
     // 1. System Defaults
     // 2. User Settings
     // 3. Workspace Settings
     // 4. System Settings (as overrides)
-    //
-    // For properties that are arrays (e.g., includeDirectories), the arrays
-    // are concatenated. For objects (e.g., customThemes), they are merged.
-    return {
-        ...systemDefaults,
-        ...user,
-        ...safeWorkspaceWithoutFolderTrust,
-        ...system,
-        general: {
-            ...(systemDefaults.general || {}),
-            ...(user.general || {}),
-            ...(safeWorkspaceWithoutFolderTrust.general || {}),
-            ...(system.general || {}),
-        },
-        ui: {
-            ...(systemDefaults.ui || {}),
-            ...(user.ui || {}),
-            ...(safeWorkspaceWithoutFolderTrust.ui || {}),
-            ...(system.ui || {}),
-            customThemes: {
-                ...(systemDefaults.ui?.customThemes || {}),
-                ...(user.ui?.customThemes || {}),
-                ...(safeWorkspaceWithoutFolderTrust.ui?.customThemes || {}),
-                ...(system.ui?.customThemes || {}),
-            },
-        },
-        ide: {
-            ...(systemDefaults.ide || {}),
-            ...(user.ide || {}),
-            ...(safeWorkspaceWithoutFolderTrust.ide || {}),
-            ...(system.ide || {}),
-        },
-        privacy: {
-            ...(systemDefaults.privacy || {}),
-            ...(user.privacy || {}),
-            ...(safeWorkspaceWithoutFolderTrust.privacy || {}),
-            ...(system.privacy || {}),
-        },
-        telemetry: {
-            ...(systemDefaults.telemetry || {}),
-            ...(user.telemetry || {}),
-            ...(safeWorkspaceWithoutFolderTrust.telemetry || {}),
-            ...(system.telemetry || {}),
-        },
-        security: {
-            ...(systemDefaults.security || {}),
-            ...(user.security || {}),
-            ...(safeWorkspaceWithoutFolderTrust.security || {}),
-            ...(system.security || {}),
-        },
-        mcp: {
-            ...(systemDefaults.mcp || {}),
-            ...(user.mcp || {}),
-            ...(safeWorkspaceWithoutFolderTrust.mcp || {}),
-            ...(system.mcp || {}),
-        },
-        mcpServers: {
-            ...(systemDefaults.mcpServers || {}),
-            ...(user.mcpServers || {}),
-            ...(safeWorkspaceWithoutFolderTrust.mcpServers || {}),
-            ...(system.mcpServers || {}),
-        },
-        tools: {
-            ...(systemDefaults.tools || {}),
-            ...(user.tools || {}),
-            ...(safeWorkspaceWithoutFolderTrust.tools || {}),
-            ...(system.tools || {}),
-        },
-        context: {
-            ...(systemDefaults.context || {}),
-            ...(user.context || {}),
-            ...(safeWorkspaceWithoutFolderTrust.context || {}),
-            ...(system.context || {}),
-            includeDirectories: [
-                ...(systemDefaults.context?.includeDirectories || []),
-                ...(user.context?.includeDirectories || []),
-                ...(safeWorkspaceWithoutFolderTrust.context?.includeDirectories || []),
-                ...(system.context?.includeDirectories || []),
-            ],
-        },
-        model: {
-            ...(systemDefaults.model || {}),
-            ...(user.model || {}),
-            ...(safeWorkspaceWithoutFolderTrust.model || {}),
-            ...(system.model || {}),
-            chatCompression: {
-                ...(systemDefaults.model?.chatCompression || {}),
-                ...(user.model?.chatCompression || {}),
-                ...(safeWorkspaceWithoutFolderTrust.model?.chatCompression || {}),
-                ...(system.model?.chatCompression || {}),
-            },
-        },
-        advanced: {
-            ...(systemDefaults.advanced || {}),
-            ...(user.advanced || {}),
-            ...(safeWorkspaceWithoutFolderTrust.advanced || {}),
-            ...(system.advanced || {}),
-            excludedEnvVars: [
-                ...new Set([
-                    ...(systemDefaults.advanced?.excludedEnvVars || []),
-                    ...(user.advanced?.excludedEnvVars || []),
-                    ...(safeWorkspaceWithoutFolderTrust.advanced?.excludedEnvVars || []),
-                    ...(system.advanced?.excludedEnvVars || []),
-                ]),
-            ],
-        },
-        experimental: {
-            ...(systemDefaults.experimental || {}),
-            ...(user.experimental || {}),
-            ...(safeWorkspaceWithoutFolderTrust.experimental || {}),
-            ...(system.experimental || {}),
-        },
-        contentGenerator: {
-            ...(systemDefaults.contentGenerator || {}),
-            ...(user.contentGenerator || {}),
-            ...(safeWorkspaceWithoutFolderTrust.contentGenerator || {}),
-            ...(system.contentGenerator || {}),
-        },
-        systemPromptMappings: {
-            ...(systemDefaults.systemPromptMappings || {}),
-            ...(user.systemPromptMappings || {}),
-            ...(safeWorkspaceWithoutFolderTrust.systemPromptMappings || {}),
-            ...(system.systemPromptMappings || {}),
-        },
-        extensions: {
-            ...(systemDefaults.extensions || {}),
-            ...(user.extensions || {}),
-            ...(safeWorkspaceWithoutFolderTrust.extensions || {}),
-            ...(system.extensions || {}),
-            disabled: [
-                ...new Set([
-                    ...(systemDefaults.extensions?.disabled || []),
-                    ...(user.extensions?.disabled || []),
-                    ...(safeWorkspaceWithoutFolderTrust.extensions?.disabled || []),
-                    ...(system.extensions?.disabled || []),
-                ]),
-            ],
-            workspacesWithMigrationNudge: [
-                ...new Set([
-                    ...(systemDefaults.extensions?.workspacesWithMigrationNudge || []),
-                    ...(user.extensions?.workspacesWithMigrationNudge || []),
-                    ...(safeWorkspaceWithoutFolderTrust.extensions
-                        ?.workspacesWithMigrationNudge || []),
-                    ...(system.extensions?.workspacesWithMigrationNudge || []),
-                ]),
-            ],
-        },
-    };
+    return customDeepMerge(getMergeStrategyForPath, {}, // Start with an empty object
+    systemDefaults, user, safeWorkspace, system);
 }
 export class LoadedSettings {
-    constructor(system, systemDefaults, user, workspace, errors, isTrusted, migratedInMemorScopes) {
+    constructor(system, systemDefaults, user, workspace, isTrusted, migratedInMemorScopes) {
         this.system = system;
         this.systemDefaults = systemDefaults;
         this.user = user;
         this.workspace = workspace;
-        this.errors = errors;
         this.isTrusted = isTrusted;
         this.migratedInMemorScopes = migratedInMemorScopes;
         this._merged = this.computeMergedSettings();
@@ -372,7 +313,6 @@ export class LoadedSettings {
     systemDefaults;
     user;
     workspace;
-    errors;
     isTrusted;
     migratedInMemorScopes;
     _merged;
@@ -399,49 +339,29 @@ export class LoadedSettings {
     setValue(scope, key, value) {
         const settingsFile = this.forScope(scope);
         setNestedProperty(settingsFile.settings, key, value);
+        setNestedProperty(settingsFile.originalSettings, key, value);
         this._merged = this.computeMergedSettings();
         saveSettings(settingsFile);
     }
 }
-function resolveEnvVarsInString(value) {
-    const envVarRegex = /\$(?:(\w+)|{([^}]+)})/g; // Find $VAR_NAME or ${VAR_NAME}
-    return value.replace(envVarRegex, (match, varName1, varName2) => {
-        const varName = varName1 || varName2;
-        if (process && process.env && typeof process.env[varName] === 'string') {
-            return process.env[varName];
-        }
-        return match;
-    });
-}
-function resolveEnvVarsInObject(obj) {
-    if (obj === null ||
-        obj === undefined ||
-        typeof obj === 'boolean' ||
-        typeof obj === 'number') {
-        return obj;
-    }
-    if (typeof obj === 'string') {
-        return resolveEnvVarsInString(obj);
-    }
-    if (Array.isArray(obj)) {
-        return obj.map((item) => resolveEnvVarsInObject(item));
-    }
-    if (typeof obj === 'object') {
-        const newObj = { ...obj };
-        for (const key in newObj) {
-            if (Object.prototype.hasOwnProperty.call(newObj, key)) {
-                newObj[key] = resolveEnvVarsInObject(newObj[key]);
-            }
-        }
-        return newObj;
-    }
-    return obj;
+/**
+ * Creates a minimal LoadedSettings instance with empty settings.
+ * Used in stream-json mode where settings are ignored.
+ */
+export function createMinimalSettings() {
+    const emptySettingsFile = {
+        path: '',
+        settings: {},
+        originalSettings: {},
+        rawJson: '{}',
+    };
+    return new LoadedSettings(emptySettingsFile, emptySettingsFile, emptySettingsFile, emptySettingsFile, false, new Set());
 }
 function findEnvFile(startDir) {
     let currentDir = path.resolve(startDir);
     while (true) {
-        // prefer gemini-specific .env under GEMINI_DIR
-        const geminiEnvPath = path.join(currentDir, GEMINI_DIR, '.env');
+        // prefer gemini-specific .env under QWEN_DIR
+        const geminiEnvPath = path.join(currentDir, QWEN_DIR, '.env');
         if (fs.existsSync(geminiEnvPath)) {
             return geminiEnvPath;
         }
@@ -452,7 +372,7 @@ function findEnvFile(startDir) {
         const parentDir = path.dirname(currentDir);
         if (parentDir === currentDir || !parentDir) {
             // check .env under home as fallback, again preferring gemini-specific .env
-            const homeGeminiEnvPath = path.join(homedir(), GEMINI_DIR, '.env');
+            const homeGeminiEnvPath = path.join(homedir(), QWEN_DIR, '.env');
             if (fs.existsSync(homeGeminiEnvPath)) {
                 return homeGeminiEnvPath;
             }
@@ -490,34 +410,21 @@ export function setUpCloudShellEnvironment(envFilePath) {
 }
 export function loadEnvironment(settings) {
     const envFilePath = findEnvFile(process.cwd());
+    if (!isWorkspaceTrusted(settings).isTrusted) {
+        return;
+    }
     // Cloud Shell environment variable handling
     if (process.env['CLOUD_SHELL'] === 'true') {
         setUpCloudShellEnvironment(envFilePath);
     }
-    // If no settings provided, try to load workspace settings for exclusions
-    let resolvedSettings = settings;
-    if (!resolvedSettings) {
-        const workspaceSettingsPath = new Storage(process.cwd()).getWorkspaceSettingsPath();
-        try {
-            if (fs.existsSync(workspaceSettingsPath)) {
-                const workspaceContent = fs.readFileSync(workspaceSettingsPath, 'utf-8');
-                const parsedWorkspaceSettings = JSON.parse(stripJsonComments(workspaceContent));
-                resolvedSettings = resolveEnvVarsInObject(parsedWorkspaceSettings);
-            }
-        }
-        catch (_e) {
-            // Ignore errors loading workspace settings
-        }
-    }
     if (envFilePath) {
         // Manually parse and load environment variables to handle exclusions correctly.
         // This avoids modifying environment variables that were already set from the shell.
         try {
             const envFileContent = fs.readFileSync(envFilePath, 'utf-8');
             const parsedEnv = dotenv.parse(envFileContent);
-            const excludedVars = resolvedSettings?.advanced?.excludedEnvVars ||
-                DEFAULT_EXCLUDED_ENV_VARS;
-            const isProjectEnvFile = !envFilePath.includes(GEMINI_DIR);
+            const excludedVars = settings?.advanced?.excludedEnvVars || DEFAULT_EXCLUDED_ENV_VARS;
+            const isProjectEnvFile = !envFilePath.includes(QWEN_DIR);
             for (const key in parsedEnv) {
                 if (Object.hasOwn(parsedEnv, key)) {
                     // If it's a project .env file, skip loading excluded variables.
@@ -540,7 +447,7 @@ export function loadEnvironment(settings) {
  * Loads settings from user and workspace directories.
  * Project settings override user settings.
  */
-export function loadSettings(workspaceDir) {
+export function loadSettings(workspaceDir = process.cwd()) {
     let systemSettings = {};
     let systemDefaultSettings = {};
     let userSettings = {};
@@ -575,7 +482,7 @@ export function loadSettings(workspaceDir) {
                         message: 'Settings file is not a valid JSON object.',
                         path: filePath,
                     });
-                    return {};
+                    return { settings: {} };
                 }
                 let settingsObject = rawSettings;
                 if (needsMigration(settingsObject)) {
@@ -596,7 +503,19 @@ export function loadSettings(workspaceDir) {
                         settingsObject = migratedSettings;
                     }
                 }
-                return settingsObject;
+                else if (!(SETTINGS_VERSION_KEY in settingsObject)) {
+                    // No migration needed, but version field is missing - add it for future optimizations
+                    settingsObject[SETTINGS_VERSION_KEY] = SETTINGS_VERSION;
+                    if (MIGRATE_V2_OVERWRITE) {
+                        try {
+                            fs.writeFileSync(filePath, JSON.stringify(settingsObject, null, 2), 'utf-8');
+                        }
+                        catch (e) {
+                            console.error(`Error adding version to settings file: ${getErrorMessage(e)}`);
+                        }
+                    }
+                }
+                return { settings: settingsObject, rawJson: content };
             }
         }
         catch (error) {
@@ -605,14 +524,27 @@ export function loadSettings(workspaceDir) {
                 path: filePath,
             });
         }
-        return {};
+        return { settings: {} };
+    };
+    const systemResult = loadAndMigrate(systemSettingsPath, SettingScope.System);
+    const systemDefaultsResult = loadAndMigrate(systemDefaultsPath, SettingScope.SystemDefaults);
+    const userResult = loadAndMigrate(USER_SETTINGS_PATH, SettingScope.User);
+    let workspaceResult = {
+        settings: {},
+        rawJson: undefined,
     };
-    systemSettings = loadAndMigrate(systemSettingsPath, SettingScope.System);
-    systemDefaultSettings = loadAndMigrate(systemDefaultsPath, SettingScope.SystemDefaults);
-    userSettings = loadAndMigrate(USER_SETTINGS_PATH, SettingScope.User);
     if (realWorkspaceDir !== realHomeDir) {
-        workspaceSettings = loadAndMigrate(workspaceSettingsPath, SettingScope.Workspace);
-    }
+        workspaceResult = loadAndMigrate(workspaceSettingsPath, SettingScope.Workspace);
+    }
+    const systemOriginalSettings = structuredClone(systemResult.settings);
+    const systemDefaultsOriginalSettings = structuredClone(systemDefaultsResult.settings);
+    const userOriginalSettings = structuredClone(userResult.settings);
+    const workspaceOriginalSettings = structuredClone(workspaceResult.settings);
+    // Environment variables for runtime use
+    systemSettings = resolveEnvVarsInObject(systemResult.settings);
+    systemDefaultSettings = resolveEnvVarsInObject(systemDefaultsResult.settings);
+    userSettings = resolveEnvVarsInObject(userResult.settings);
+    workspaceSettings = resolveEnvVarsInObject(workspaceResult.settings);
     // Support legacy theme names
     if (userSettings.ui?.theme === 'VS') {
         userSettings.ui.theme = DefaultLight.name;
@@ -627,32 +559,55 @@ export function loadSettings(workspaceDir) {
         workspaceSettings.ui.theme = DefaultDark.name;
     }
     // For the initial trust check, we can only use user and system settings.
-    const initialTrustCheckSettings = mergeWith({}, systemSettings, userSettings);
-    const isTrusted = isWorkspaceTrusted(initialTrustCheckSettings) ?? true;
+    const initialTrustCheckSettings = customDeepMerge(getMergeStrategyForPath, {}, systemSettings, userSettings);
+    const isTrusted = isWorkspaceTrusted(initialTrustCheckSettings).isTrusted ?? true;
     // Create a temporary merged settings object to pass to loadEnvironment.
     const tempMergedSettings = mergeSettings(systemSettings, systemDefaultSettings, userSettings, workspaceSettings, isTrusted);
     // loadEnviroment depends on settings so we have to create a temp version of
     // the settings to avoid a cycle
     loadEnvironment(tempMergedSettings);
-    // Now that the environment is loaded, resolve variables in the settings.
-    systemSettings = resolveEnvVarsInObject(systemSettings);
-    userSettings = resolveEnvVarsInObject(userSettings);
-    workspaceSettings = resolveEnvVarsInObject(workspaceSettings);
     // Create LoadedSettings first
-    const loadedSettings = new LoadedSettings({
+    if (settingsErrors.length > 0) {
+        const errorMessages = settingsErrors.map((error) => `Error in ${error.path}: ${error.message}`);
+        throw new FatalConfigError(`${errorMessages.join('\n')}\nPlease fix the configuration file(s) and try again.`);
+    }
+    return new LoadedSettings({
         path: systemSettingsPath,
         settings: systemSettings,
+        originalSettings: systemOriginalSettings,
+        rawJson: systemResult.rawJson,
     }, {
         path: systemDefaultsPath,
         settings: systemDefaultSettings,
+        originalSettings: systemDefaultsOriginalSettings,
+        rawJson: systemDefaultsResult.rawJson,
     }, {
         path: USER_SETTINGS_PATH,
         settings: userSettings,
+        originalSettings: userOriginalSettings,
+        rawJson: userResult.rawJson,
     }, {
         path: workspaceSettingsPath,
         settings: workspaceSettings,
-    }, settingsErrors, isTrusted, migratedInMemorScopes);
-    return loadedSettings;
+        originalSettings: workspaceOriginalSettings,
+        rawJson: workspaceResult.rawJson,
+    }, isTrusted, migratedInMemorScopes);
+}
+export function migrateDeprecatedSettings(loadedSettings, workspaceDir = process.cwd()) {
+    const processScope = (scope) => {
+        const settings = loadedSettings.forScope(scope).settings;
+        if (settings.extensions?.disabled) {
+            console.log(`Migrating deprecated extensions.disabled settings from ${scope} settings...`);
+            for (const extension of settings.extensions.disabled ?? []) {
+                disableExtension(extension, scope, workspaceDir);
+            }
+            const newExtensionsValue = { ...settings.extensions };
+            newExtensionsValue.disabled = undefined;
+            loadedSettings.setValue(scope, 'extensions', newExtensionsValue);
+        }
+    };
+    processScope(SettingScope.User);
+    processScope(SettingScope.Workspace);
 }
 export function saveSettings(settingsFile) {
     try {
@@ -661,14 +616,16 @@ export function saveSettings(settingsFile) {
         if (!fs.existsSync(dirPath)) {
             fs.mkdirSync(dirPath, { recursive: true });
         }
-        let settingsToSave = settingsFile.settings;
+        let settingsToSave = settingsFile.originalSettings;
         if (!MIGRATE_V2_OVERWRITE) {
             settingsToSave = migrateSettingsToV1(settingsToSave);
         }
-        fs.writeFileSync(settingsFile.path, JSON.stringify(settingsToSave, null, 2), 'utf-8');
+        // Use the format-preserving update function
+        updateSettingsFilePreservingFormat(settingsFile.path, settingsToSave);
     }
     catch (error) {
         console.error('Error saving user settings file:', error);
+        throw error;
     }
 }
 //# sourceMappingURL=settings.js.map