1use crate::*;
  2use anyhow::{Context as _, Result, anyhow};
  3use collections::HashMap;
  4use fs::Fs;
  5use paths::{cursor_settings_file_paths, vscode_settings_file_paths};
  6use serde::Deserialize;
  7use serde_json::{Map, Value};
  8use std::{
  9    num::{NonZeroU32, NonZeroUsize},
 10    path::{Path, PathBuf},
 11    sync::Arc,
 12};
 13
 14#[derive(Clone, Copy, PartialEq, Eq, Debug)]
 15pub enum VsCodeSettingsSource {
 16    VsCode,
 17    Cursor,
 18}
 19
 20impl std::fmt::Display for VsCodeSettingsSource {
 21    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 22        match self {
 23            VsCodeSettingsSource::VsCode => write!(f, "VS Code"),
 24            VsCodeSettingsSource::Cursor => write!(f, "Cursor"),
 25        }
 26    }
 27}
 28
 29pub struct VsCodeSettings {
 30    pub source: VsCodeSettingsSource,
 31    pub path: Arc<Path>,
 32    content: Map<String, Value>,
 33}
 34
 35impl VsCodeSettings {
 36    #[cfg(any(test, feature = "test-support"))]
 37    pub fn from_str(content: &str, source: VsCodeSettingsSource) -> Result<Self> {
 38        Ok(Self {
 39            source,
 40            path: Path::new("/example-path/Code/User/settings.json").into(),
 41            content: serde_json_lenient::from_str(content)?,
 42        })
 43    }
 44
 45    pub async fn load_user_settings(source: VsCodeSettingsSource, fs: Arc<dyn Fs>) -> Result<Self> {
 46        let candidate_paths = match source {
 47            VsCodeSettingsSource::VsCode => vscode_settings_file_paths(),
 48            VsCodeSettingsSource::Cursor => cursor_settings_file_paths(),
 49        };
 50        let mut path = None;
 51        for candidate_path in candidate_paths.iter() {
 52            if fs.is_file(candidate_path).await {
 53                path = Some(candidate_path.clone());
 54            }
 55        }
 56        let Some(path) = path else {
 57            return Err(anyhow!(
 58                "No settings file found, expected to find it in one of the following paths:\n{}",
 59                candidate_paths
 60                    .into_iter()
 61                    .map(|path| path.to_string_lossy().into_owned())
 62                    .collect::<Vec<_>>()
 63                    .join("\n")
 64            ));
 65        };
 66        let content = fs.load(&path).await.with_context(|| {
 67            format!(
 68                "Error loading {} settings file from {}",
 69                source,
 70                path.display()
 71            )
 72        })?;
 73        let content = serde_json_lenient::from_str(&content).with_context(|| {
 74            format!(
 75                "Error parsing {} settings file from {}",
 76                source,
 77                path.display()
 78            )
 79        })?;
 80        Ok(Self {
 81            source,
 82            path: path.into(),
 83            content,
 84        })
 85    }
 86
 87    fn read_value(&self, setting: &str) -> Option<&Value> {
 88        self.content.get(setting)
 89    }
 90
 91    fn read_str(&self, setting: &str) -> Option<&str> {
 92        self.read_value(setting).and_then(|v| v.as_str())
 93    }
 94
 95    fn read_string(&self, setting: &str) -> Option<String> {
 96        self.read_value(setting)
 97            .and_then(|v| v.as_str())
 98            .map(|s| s.to_owned())
 99    }
100
101    fn read_bool(&self, setting: &str) -> Option<bool> {
102        self.read_value(setting).and_then(|v| v.as_bool())
103    }
104
105    fn read_f32(&self, setting: &str) -> Option<f32> {
106        self.read_value(setting)
107            .and_then(|v| v.as_f64())
108            .map(|v| v as f32)
109    }
110
111    fn read_u64(&self, setting: &str) -> Option<u64> {
112        self.read_value(setting).and_then(|v| v.as_u64())
113    }
114
115    fn read_usize(&self, setting: &str) -> Option<usize> {
116        self.read_value(setting)
117            .and_then(|v| v.as_u64())
118            .and_then(|v| v.try_into().ok())
119    }
120
121    fn read_u32(&self, setting: &str) -> Option<u32> {
122        self.read_value(setting)
123            .and_then(|v| v.as_u64())
124            .and_then(|v| v.try_into().ok())
125    }
126
127    fn read_enum<T>(&self, key: &str, f: impl FnOnce(&str) -> Option<T>) -> Option<T> {
128        self.content.get(key).and_then(Value::as_str).and_then(f)
129    }
130
131    fn read_fonts(&self, key: &str) -> (Option<FontFamilyName>, Option<Vec<FontFamilyName>>) {
132        let Some(css_name) = self.content.get(key).and_then(Value::as_str) else {
133            return (None, None);
134        };
135
136        let mut name_buffer = String::new();
137        let mut quote_char: Option<char> = None;
138        let mut fonts = Vec::new();
139        let mut add_font = |buffer: &mut String| {
140            let trimmed = buffer.trim();
141            if !trimmed.is_empty() {
142                fonts.push(trimmed.to_string().into());
143            }
144
145            buffer.clear();
146        };
147
148        for ch in css_name.chars() {
149            match (ch, quote_char) {
150                ('"' | '\'', None) => {
151                    quote_char = Some(ch);
152                }
153                (_, Some(q)) if ch == q => {
154                    quote_char = None;
155                }
156                (',', None) => {
157                    add_font(&mut name_buffer);
158                }
159                _ => {
160                    name_buffer.push(ch);
161                }
162            }
163        }
164
165        add_font(&mut name_buffer);
166        if fonts.is_empty() {
167            return (None, None);
168        }
169        (Some(fonts.remove(0)), skip_default(fonts))
170    }
171
172    pub fn settings_content(&self) -> SettingsContent {
173        SettingsContent {
174            agent: self.agent_settings_content(),
175            agent_servers: None,
176            audio: None,
177            auto_update: None,
178            base_keymap: Some(BaseKeymapContent::VSCode),
179            calls: None,
180            collaboration_panel: None,
181            debugger: None,
182            diagnostics: None,
183            disable_ai: None,
184            editor: self.editor_settings_content(),
185            extension: ExtensionSettingsContent::default(),
186            file_finder: None,
187            git: self.git_settings_content(),
188            git_panel: self.git_panel_settings_content(),
189            global_lsp_settings: None,
190            helix_mode: None,
191            image_viewer: None,
192            journal: None,
193            language_models: None,
194            line_indicator_format: None,
195            log: None,
196            message_editor: None,
197            node: self.node_binary_settings(),
198            notification_panel: None,
199            outline_panel: self.outline_panel_settings_content(),
200            preview_tabs: self.preview_tabs_settings_content(),
201            project: self.project_settings_content(),
202            project_panel: self.project_panel_settings_content(),
203            proxy: self.read_string("http.proxy"),
204            remote: RemoteSettingsContent::default(),
205            repl: None,
206            server_url: None,
207            session: None,
208            status_bar: self.status_bar_settings_content(),
209            tab_bar: self.tab_bar_settings_content(),
210            tabs: self.item_settings_content(),
211            telemetry: self.telemetry_settings_content(),
212            terminal: self.terminal_settings_content(),
213            theme: Box::new(self.theme_settings_content()),
214            title_bar: None,
215            vim: None,
216            vim_mode: None,
217            workspace: self.workspace_settings_content(),
218        }
219    }
220
221    fn agent_settings_content(&self) -> Option<AgentSettingsContent> {
222        let enabled = self.read_bool("chat.agent.enabled");
223        skip_default(AgentSettingsContent {
224            enabled: enabled,
225            button: enabled,
226            ..Default::default()
227        })
228    }
229
230    fn editor_settings_content(&self) -> EditorSettingsContent {
231        EditorSettingsContent {
232            auto_signature_help: self.read_bool("editor.parameterHints.enabled"),
233            autoscroll_on_clicks: None,
234            cursor_blink: self.read_enum("editor.cursorBlinking", |s| match s {
235                "blink" | "phase" | "expand" | "smooth" => Some(true),
236                "solid" => Some(false),
237                _ => None,
238            }),
239            cursor_shape: self.read_enum("editor.cursorStyle", |s| match s {
240                "block" => Some(CursorShape::Block),
241                "block-outline" => Some(CursorShape::Hollow),
242                "line" | "line-thin" => Some(CursorShape::Bar),
243                "underline" | "underline-thin" => Some(CursorShape::Underline),
244                _ => None,
245            }),
246            current_line_highlight: self.read_enum("editor.renderLineHighlight", |s| match s {
247                "gutter" => Some(CurrentLineHighlight::Gutter),
248                "line" => Some(CurrentLineHighlight::Line),
249                "all" => Some(CurrentLineHighlight::All),
250                _ => None,
251            }),
252            diagnostics_max_severity: None,
253            double_click_in_multibuffer: None,
254            drag_and_drop_selection: None,
255            excerpt_context_lines: None,
256            expand_excerpt_lines: None,
257            fast_scroll_sensitivity: self.read_f32("editor.fastScrollSensitivity"),
258            sticky_scroll: self.sticky_scroll_content(),
259            go_to_definition_fallback: None,
260            gutter: self.gutter_content(),
261            hide_mouse: None,
262            horizontal_scroll_margin: None,
263            hover_popover_delay: self.read_u64("editor.hover.delay").map(Into::into),
264            hover_popover_enabled: self.read_bool("editor.hover.enabled"),
265            inline_code_actions: None,
266            jupyter: None,
267            lsp_document_colors: None,
268            lsp_highlight_debounce: None,
269            middle_click_paste: None,
270            minimap: self.minimap_content(),
271            minimum_contrast_for_highlights: None,
272            multi_cursor_modifier: self.read_enum("editor.multiCursorModifier", |s| match s {
273                "ctrlCmd" => Some(MultiCursorModifier::CmdOrCtrl),
274                "alt" => Some(MultiCursorModifier::Alt),
275                _ => None,
276            }),
277            redact_private_values: None,
278            relative_line_numbers: self.read_enum("editor.lineNumbers", |s| match s {
279                "relative" => Some(RelativeLineNumbers::Enabled),
280                _ => None,
281            }),
282            rounded_selection: self.read_bool("editor.roundedSelection"),
283            scroll_beyond_last_line: None,
284            scroll_sensitivity: self.read_f32("editor.mouseWheelScrollSensitivity"),
285            scrollbar: self.scrollbar_content(),
286            search: self.search_content(),
287            search_wrap: None,
288            seed_search_query_from_cursor: self.read_enum(
289                "editor.find.seedSearchStringFromSelection",
290                |s| match s {
291                    "always" => Some(SeedQuerySetting::Always),
292                    "selection" => Some(SeedQuerySetting::Selection),
293                    "never" => Some(SeedQuerySetting::Never),
294                    _ => None,
295                },
296            ),
297            selection_highlight: self.read_bool("editor.selectionHighlight"),
298            show_signature_help_after_edits: self.read_bool("editor.parameterHints.enabled"),
299            snippet_sort_order: None,
300            toolbar: None,
301            use_smartcase_search: self.read_bool("search.smartCase"),
302            vertical_scroll_margin: self.read_f32("editor.cursorSurroundingLines"),
303            completion_menu_scrollbar: None,
304        }
305    }
306
307    fn sticky_scroll_content(&self) -> Option<StickyScrollContent> {
308        skip_default(StickyScrollContent {
309            enabled: self.read_bool("editor.stickyScroll.enabled"),
310        })
311    }
312
313    fn gutter_content(&self) -> Option<GutterContent> {
314        skip_default(GutterContent {
315            line_numbers: self.read_enum("editor.lineNumbers", |s| match s {
316                "on" | "relative" => Some(true),
317                "off" => Some(false),
318                _ => None,
319            }),
320            min_line_number_digits: None,
321            runnables: None,
322            breakpoints: None,
323            folds: self.read_enum("editor.showFoldingControls", |s| match s {
324                "always" | "mouseover" => Some(true),
325                "never" => Some(false),
326                _ => None,
327            }),
328        })
329    }
330
331    fn scrollbar_content(&self) -> Option<ScrollbarContent> {
332        let scrollbar_axes = skip_default(ScrollbarAxesContent {
333            horizontal: self.read_enum("editor.scrollbar.horizontal", |s| match s {
334                "auto" | "visible" => Some(true),
335                "hidden" => Some(false),
336                _ => None,
337            }),
338            vertical: self.read_enum("editor.scrollbar.vertical", |s| match s {
339                "auto" | "visible" => Some(true),
340                "hidden" => Some(false),
341                _ => None,
342            }),
343        })?;
344
345        Some(ScrollbarContent {
346            axes: Some(scrollbar_axes),
347            ..Default::default()
348        })
349    }
350
351    fn search_content(&self) -> Option<SearchSettingsContent> {
352        skip_default(SearchSettingsContent {
353            include_ignored: self.read_bool("search.useIgnoreFiles"),
354            ..Default::default()
355        })
356    }
357
358    fn minimap_content(&self) -> Option<MinimapContent> {
359        let minimap_enabled = self.read_bool("editor.minimap.enabled");
360        let autohide = self.read_bool("editor.minimap.autohide");
361        let show = match (minimap_enabled, autohide) {
362            (Some(true), Some(false)) => Some(ShowMinimap::Always),
363            (Some(true), _) => Some(ShowMinimap::Auto),
364            (Some(false), _) => Some(ShowMinimap::Never),
365            _ => None,
366        };
367
368        skip_default(MinimapContent {
369            show,
370            thumb: self.read_enum("editor.minimap.showSlider", |s| match s {
371                "always" => Some(MinimapThumb::Always),
372                "mouseover" => Some(MinimapThumb::Hover),
373                _ => None,
374            }),
375            max_width_columns: self
376                .read_u32("editor.minimap.maxColumn")
377                .and_then(|v| NonZeroU32::new(v)),
378            ..Default::default()
379        })
380    }
381
382    fn git_panel_settings_content(&self) -> Option<GitPanelSettingsContent> {
383        skip_default(GitPanelSettingsContent {
384            button: self.read_bool("git.enabled"),
385            fallback_branch_name: self.read_string("git.defaultBranchName"),
386            ..Default::default()
387        })
388    }
389
390    fn project_settings_content(&self) -> ProjectSettingsContent {
391        ProjectSettingsContent {
392            all_languages: AllLanguageSettingsContent {
393                features: None,
394                edit_predictions: self.edit_predictions_settings_content(),
395                defaults: self.default_language_settings_content(),
396                languages: Default::default(),
397                file_types: self.file_types(),
398            },
399            worktree: self.worktree_settings_content(),
400            lsp: Default::default(),
401            terminal: None,
402            dap: Default::default(),
403            context_servers: self.context_servers(),
404            load_direnv: None,
405            slash_commands: None,
406            git_hosting_providers: None,
407        }
408    }
409
410    fn default_language_settings_content(&self) -> LanguageSettingsContent {
411        LanguageSettingsContent {
412            allow_rewrap: None,
413            always_treat_brackets_as_autoclosed: None,
414            auto_indent: None,
415            auto_indent_on_paste: self.read_bool("editor.formatOnPaste"),
416            code_actions_on_format: None,
417            completions: skip_default(CompletionSettingsContent {
418                words: self.read_bool("editor.suggest.showWords").map(|b| {
419                    if b {
420                        WordsCompletionMode::Enabled
421                    } else {
422                        WordsCompletionMode::Disabled
423                    }
424                }),
425                ..Default::default()
426            }),
427            debuggers: None,
428            edit_predictions_disabled_in: None,
429            enable_language_server: None,
430            ensure_final_newline_on_save: self.read_bool("files.insertFinalNewline"),
431            extend_comment_on_newline: None,
432            format_on_save: self.read_bool("editor.guides.formatOnSave").map(|b| {
433                if b {
434                    FormatOnSave::On
435                } else {
436                    FormatOnSave::Off
437                }
438            }),
439            formatter: None,
440            hard_tabs: self.read_bool("editor.insertSpaces").map(|v| !v),
441            indent_guides: skip_default(IndentGuideSettingsContent {
442                enabled: self.read_bool("editor.guides.indentation"),
443                ..Default::default()
444            }),
445            inlay_hints: None,
446            jsx_tag_auto_close: None,
447            language_servers: None,
448            linked_edits: self.read_bool("editor.linkedEditing"),
449            preferred_line_length: self.read_u32("editor.wordWrapColumn"),
450            prettier: None,
451            remove_trailing_whitespace_on_save: self.read_bool("editor.trimAutoWhitespace"),
452            show_completion_documentation: None,
453            show_completions_on_input: self.read_bool("editor.suggestOnTriggerCharacters"),
454            show_edit_predictions: self.read_bool("editor.inlineSuggest.enabled"),
455            show_whitespaces: self.read_enum("editor.renderWhitespace", |s| {
456                Some(match s {
457                    "boundary" => ShowWhitespaceSetting::Boundary,
458                    "trailing" => ShowWhitespaceSetting::Trailing,
459                    "selection" => ShowWhitespaceSetting::Selection,
460                    "all" => ShowWhitespaceSetting::All,
461                    _ => ShowWhitespaceSetting::None,
462                })
463            }),
464            show_wrap_guides: None,
465            soft_wrap: self.read_enum("editor.wordWrap", |s| match s {
466                "on" => Some(SoftWrap::EditorWidth),
467                "wordWrapColumn" => Some(SoftWrap::PreferLine),
468                "bounded" => Some(SoftWrap::Bounded),
469                "off" => Some(SoftWrap::None),
470                _ => None,
471            }),
472            tab_size: self
473                .read_u32("editor.tabSize")
474                .and_then(|n| NonZeroU32::new(n)),
475            tasks: None,
476            use_auto_surround: self.read_enum("editor.autoSurround", |s| match s {
477                "languageDefined" | "quotes" | "brackets" => Some(true),
478                "never" => Some(false),
479                _ => None,
480            }),
481            use_autoclose: None,
482            use_on_type_format: self.read_bool("editor.formatOnType"),
483            whitespace_map: None,
484            wrap_guides: self
485                .read_value("editor.rulers")
486                .and_then(|v| v.as_array())
487                .map(|v| {
488                    v.iter()
489                        .flat_map(|n| n.as_u64().map(|n| n as usize))
490                        .collect()
491                }),
492        }
493    }
494
495    fn file_types(&self) -> Option<HashMap<Arc<str>, ExtendingVec<String>>> {
496        // vscodes file association map is inverted from ours, so we flip the mapping before merging
497        let mut associations: HashMap<Arc<str>, ExtendingVec<String>> = HashMap::default();
498        let map = self.read_value("files.associations")?.as_object()?;
499        for (k, v) in map {
500            let Some(v) = v.as_str() else { continue };
501            associations.entry(v.into()).or_default().0.push(k.clone());
502        }
503        skip_default(associations)
504    }
505
506    fn edit_predictions_settings_content(&self) -> Option<EditPredictionSettingsContent> {
507        let disabled_globs = self
508            .read_value("cursor.general.globalCursorIgnoreList")?
509            .as_array()?;
510
511        skip_default(EditPredictionSettingsContent {
512            disabled_globs: skip_default(
513                disabled_globs
514                    .iter()
515                    .filter_map(|glob| glob.as_str())
516                    .map(|s| s.to_string())
517                    .collect(),
518            ),
519            ..Default::default()
520        })
521    }
522
523    fn outline_panel_settings_content(&self) -> Option<OutlinePanelSettingsContent> {
524        skip_default(OutlinePanelSettingsContent {
525            file_icons: self.read_bool("outline.icons"),
526            folder_icons: self.read_bool("outline.icons"),
527            git_status: self.read_bool("git.decorations.enabled"),
528            ..Default::default()
529        })
530    }
531
532    fn node_binary_settings(&self) -> Option<NodeBinarySettings> {
533        // this just sets the binary name instead of a full path so it relies on path lookup
534        // resolving to the one you want
535        skip_default(NodeBinarySettings {
536            npm_path: self.read_enum("npm.packageManager", |s| match s {
537                v @ ("npm" | "yarn" | "bun" | "pnpm") => Some(v.to_owned()),
538                _ => None,
539            }),
540            ..Default::default()
541        })
542    }
543
544    fn git_settings_content(&self) -> Option<GitSettings> {
545        let inline_blame = self.read_bool("git.blame.editorDecoration.enabled")?;
546        skip_default(GitSettings {
547            inline_blame: Some(InlineBlameSettings {
548                enabled: Some(inline_blame),
549                ..Default::default()
550            }),
551            ..Default::default()
552        })
553    }
554
555    fn context_servers(&self) -> HashMap<Arc<str>, ContextServerSettingsContent> {
556        #[derive(Deserialize)]
557        struct VsCodeContextServerCommand {
558            command: PathBuf,
559            args: Option<Vec<String>>,
560            env: Option<HashMap<String, String>>,
561            // note: we don't support envFile and type
562        }
563        let Some(mcp) = self.read_value("mcp").and_then(|v| v.as_object()) else {
564            return Default::default();
565        };
566        mcp.iter()
567            .filter_map(|(k, v)| {
568                Some((
569                    k.clone().into(),
570                    ContextServerSettingsContent::Custom {
571                        enabled: true,
572                        command: serde_json::from_value::<VsCodeContextServerCommand>(v.clone())
573                            .ok()
574                            .map(|cmd| ContextServerCommand {
575                                path: cmd.command,
576                                args: cmd.args.unwrap_or_default(),
577                                env: cmd.env,
578                                timeout: None,
579                            })?,
580                    },
581                ))
582            })
583            .collect()
584    }
585
586    fn item_settings_content(&self) -> Option<ItemSettingsContent> {
587        skip_default(ItemSettingsContent {
588            git_status: self.read_bool("git.decorations.enabled"),
589            close_position: self.read_enum("workbench.editor.tabActionLocation", |s| match s {
590                "right" => Some(ClosePosition::Right),
591                "left" => Some(ClosePosition::Left),
592                _ => None,
593            }),
594            file_icons: self.read_bool("workbench.editor.showIcons"),
595            activate_on_close: self
596                .read_bool("workbench.editor.focusRecentEditorAfterClose")
597                .map(|b| {
598                    if b {
599                        ActivateOnClose::History
600                    } else {
601                        ActivateOnClose::LeftNeighbour
602                    }
603                }),
604            show_diagnostics: None,
605            show_close_button: self
606                .read_bool("workbench.editor.tabActionCloseVisibility")
607                .map(|b| {
608                    if b {
609                        ShowCloseButton::Always
610                    } else {
611                        ShowCloseButton::Hidden
612                    }
613                }),
614        })
615    }
616
617    fn preview_tabs_settings_content(&self) -> Option<PreviewTabsSettingsContent> {
618        skip_default(PreviewTabsSettingsContent {
619            enabled: self.read_bool("workbench.editor.enablePreview"),
620            enable_preview_from_file_finder: self
621                .read_bool("workbench.editor.enablePreviewFromQuickOpen"),
622            enable_preview_from_code_navigation: self
623                .read_bool("workbench.editor.enablePreviewFromCodeNavigation"),
624        })
625    }
626
627    fn tab_bar_settings_content(&self) -> Option<TabBarSettingsContent> {
628        skip_default(TabBarSettingsContent {
629            show: self.read_enum("workbench.editor.showTabs", |s| match s {
630                "multiple" => Some(true),
631                "single" | "none" => Some(false),
632                _ => None,
633            }),
634            show_nav_history_buttons: None,
635            show_tab_bar_buttons: self
636                .read_str("workbench.editor.editorActionsLocation")
637                .and_then(|str| if str == "hidden" { Some(false) } else { None }),
638        })
639    }
640
641    fn status_bar_settings_content(&self) -> Option<StatusBarSettingsContent> {
642        skip_default(StatusBarSettingsContent {
643            show: self.read_bool("workbench.statusBar.visible"),
644            active_language_button: None,
645            cursor_position_button: None,
646            line_endings_button: None,
647        })
648    }
649
650    fn project_panel_settings_content(&self) -> Option<ProjectPanelSettingsContent> {
651        let mut project_panel_settings = ProjectPanelSettingsContent {
652            auto_fold_dirs: self.read_bool("explorer.compactFolders"),
653            auto_reveal_entries: self.read_bool("explorer.autoReveal"),
654            button: None,
655            default_width: None,
656            dock: None,
657            drag_and_drop: None,
658            entry_spacing: None,
659            file_icons: None,
660            folder_icons: None,
661            git_status: self.read_bool("git.decorations.enabled"),
662            hide_gitignore: self.read_bool("explorer.excludeGitIgnore"),
663            hide_hidden: None,
664            hide_root: None,
665            indent_guides: None,
666            indent_size: None,
667            open_file_on_paste: None,
668            scrollbar: None,
669            show_diagnostics: self
670                .read_bool("problems.decorations.enabled")
671                .and_then(|b| if b { Some(ShowDiagnostics::Off) } else { None }),
672            starts_open: None,
673            sticky_scroll: None,
674        };
675
676        if let (Some(false), Some(false)) = (
677            self.read_bool("explorer.decorations.badges"),
678            self.read_bool("explorer.decorations.colors"),
679        ) {
680            project_panel_settings.git_status = Some(false);
681            project_panel_settings.show_diagnostics = Some(ShowDiagnostics::Off);
682        }
683
684        skip_default(project_panel_settings)
685    }
686
687    fn telemetry_settings_content(&self) -> Option<TelemetrySettingsContent> {
688        self.read_enum("telemetry.telemetryLevel", |level| {
689            let (metrics, diagnostics) = match level {
690                "all" => (true, true),
691                "error" | "crash" => (false, true),
692                "off" => (false, false),
693                _ => return None,
694            };
695            Some(TelemetrySettingsContent {
696                metrics: Some(metrics),
697                diagnostics: Some(diagnostics),
698            })
699        })
700    }
701
702    fn terminal_settings_content(&self) -> Option<TerminalSettingsContent> {
703        let (font_family, font_fallbacks) = self.read_fonts("terminal.integrated.fontFamily");
704        skip_default(TerminalSettingsContent {
705            alternate_scroll: None,
706            blinking: self
707                .read_bool("terminal.integrated.cursorBlinking")
708                .map(|b| {
709                    if b {
710                        TerminalBlink::On
711                    } else {
712                        TerminalBlink::Off
713                    }
714                }),
715            button: None,
716            copy_on_select: self.read_bool("terminal.integrated.copyOnSelection"),
717            cursor_shape: self.read_enum("terminal.integrated.cursorStyle", |s| match s {
718                "block" => Some(CursorShapeContent::Block),
719                "line" => Some(CursorShapeContent::Bar),
720                "underline" => Some(CursorShapeContent::Underline),
721                _ => None,
722            }),
723            default_height: None,
724            default_width: None,
725            dock: None,
726            font_fallbacks,
727            font_family,
728            font_features: None,
729            font_size: self.read_f32("terminal.integrated.fontSize"),
730            font_weight: None,
731            keep_selection_on_copy: None,
732            line_height: self
733                .read_f32("terminal.integrated.lineHeight")
734                .map(|lh| TerminalLineHeight::Custom(lh)),
735            max_scroll_history_lines: self.read_usize("terminal.integrated.scrollback"),
736            minimum_contrast: None,
737            option_as_meta: self.read_bool("terminal.integrated.macOptionIsMeta"),
738            project: self.project_terminal_settings_content(),
739            scrollbar: None,
740            toolbar: None,
741        })
742    }
743
744    fn project_terminal_settings_content(&self) -> ProjectTerminalSettingsContent {
745        #[cfg(target_os = "windows")]
746        let platform = "windows";
747        #[cfg(target_os = "linux")]
748        let platform = "linux";
749        #[cfg(target_os = "macos")]
750        let platform = "osx";
751        #[cfg(target_os = "freebsd")]
752        let platform = "freebsd";
753        let env = self
754            .read_value(&format!("terminal.integrated.env.{platform}"))
755            .and_then(|v| v.as_object())
756            .map(|v| {
757                v.iter()
758                    .map(|(k, v)| (k.clone(), v.to_string()))
759                    // zed does not support substitutions, so this can break env vars
760                    .filter(|(_, v)| !v.contains('$'))
761                    .collect()
762            });
763
764        ProjectTerminalSettingsContent {
765            // TODO: handle arguments
766            shell: self
767                .read_string(&format!("terminal.integrated.{platform}Exec"))
768                .map(|s| Shell::Program(s)),
769            working_directory: None,
770            env,
771            detect_venv: None,
772        }
773    }
774
775    fn theme_settings_content(&self) -> ThemeSettingsContent {
776        let (buffer_font_family, buffer_font_fallbacks) = self.read_fonts("editor.fontFamily");
777        ThemeSettingsContent {
778            ui_font_size: None,
779            ui_font_family: None,
780            ui_font_fallbacks: None,
781            ui_font_features: None,
782            ui_font_weight: None,
783            buffer_font_family,
784            buffer_font_fallbacks,
785            buffer_font_size: self.read_f32("editor.fontSize"),
786            buffer_font_weight: self.read_f32("editor.fontWeight").map(|w| w.into()),
787            buffer_line_height: None,
788            buffer_font_features: None,
789            agent_ui_font_size: None,
790            agent_buffer_font_size: None,
791            theme: None,
792            icon_theme: None,
793            ui_density: None,
794            unnecessary_code_fade: None,
795            experimental_theme_overrides: None,
796            theme_overrides: Default::default(),
797        }
798    }
799
800    fn workspace_settings_content(&self) -> WorkspaceSettingsContent {
801        WorkspaceSettingsContent {
802            active_pane_modifiers: self.active_pane_modifiers(),
803            autosave: self.read_enum("files.autoSave", |s| match s {
804                "off" => Some(AutosaveSetting::Off),
805                "afterDelay" => Some(AutosaveSetting::AfterDelay {
806                    milliseconds: self
807                        .read_value("files.autoSaveDelay")
808                        .and_then(|v| v.as_u64())
809                        .unwrap_or(1000)
810                        .into(),
811                }),
812                "onFocusChange" => Some(AutosaveSetting::OnFocusChange),
813                "onWindowChange" => Some(AutosaveSetting::OnWindowChange),
814                _ => None,
815            }),
816            bottom_dock_layout: None,
817            centered_layout: None,
818            close_on_file_delete: None,
819            command_aliases: Default::default(),
820            confirm_quit: self.read_enum("window.confirmBeforeClose", |s| match s {
821                "always" | "keyboardOnly" => Some(true),
822                "never" => Some(false),
823                _ => None,
824            }),
825            drop_target_size: None,
826            // workbench.editor.limit contains "enabled", "value", and "perEditorGroup"
827            // our semantics match if those are set to true, some N, and true respectively.
828            // we'll ignore "perEditorGroup" for now since we only support a global max
829            max_tabs: if self.read_bool("workbench.editor.limit.enabled") == Some(true) {
830                self.read_usize("workbench.editor.limit.value")
831                    .and_then(|n| NonZeroUsize::new(n))
832            } else {
833                None
834            },
835            on_last_window_closed: None,
836            pane_split_direction_horizontal: None,
837            pane_split_direction_vertical: None,
838            resize_all_panels_in_dock: None,
839            restore_on_file_reopen: self.read_bool("workbench.editor.restoreViewState"),
840            restore_on_startup: None,
841            show_call_status_icon: None,
842            use_system_path_prompts: self.read_bool("files.simpleDialog.enable"),
843            use_system_prompts: None,
844            use_system_window_tabs: self.read_bool("window.nativeTabs"),
845            when_closing_with_no_tabs: self.read_bool("window.closeWhenEmpty").map(|b| {
846                if b {
847                    CloseWindowWhenNoItems::CloseWindow
848                } else {
849                    CloseWindowWhenNoItems::KeepWindowOpen
850                }
851            }),
852            zoomed_padding: None,
853        }
854    }
855
856    fn active_pane_modifiers(&self) -> Option<ActivePaneModifiers> {
857        if self.read_bool("accessibility.dimUnfocused.enabled") == Some(true)
858            && let Some(opacity) = self.read_f32("accessibility.dimUnfocused.opacity")
859        {
860            Some(ActivePaneModifiers {
861                border_size: None,
862                inactive_opacity: Some(InactiveOpacity(opacity)),
863            })
864        } else {
865            None
866        }
867    }
868
869    fn worktree_settings_content(&self) -> WorktreeSettingsContent {
870        WorktreeSettingsContent {
871            project_name: crate::Maybe::Unset,
872            prevent_sharing_in_public_channels: false,
873            file_scan_exclusions: self
874                .read_value("files.watcherExclude")
875                .and_then(|v| v.as_array())
876                .map(|v| {
877                    v.iter()
878                        .filter_map(|n| n.as_str().map(str::to_owned))
879                        .collect::<Vec<_>>()
880                })
881                .filter(|r| !r.is_empty()),
882            file_scan_inclusions: self
883                .read_value("files.watcherInclude")
884                .and_then(|v| v.as_array())
885                .map(|v| {
886                    v.iter()
887                        .filter_map(|n| n.as_str().map(str::to_owned))
888                        .collect::<Vec<_>>()
889                })
890                .filter(|r| !r.is_empty()),
891            private_files: None,
892            hidden_files: None,
893        }
894    }
895}
896
897fn skip_default<T: Default + PartialEq>(value: T) -> Option<T> {
898    if value == T::default() {
899        None
900    } else {
901        Some(value)
902    }
903}