diff --git a/CODESMELL.md b/CODESMELL.md index 9a098c0..4957ad3 100644 --- a/CODESMELL.md +++ b/CODESMELL.md @@ -91,9 +91,9 @@ _None._ All modules previously on the queue have been split; refresh the queue i ## 8. `String.to_existing_atom/1` + `rescue ArgumentError` -**Status:** open, low priority. +**Status:** ✅ done (2026-05-01). `String.to_existing_atom/1` call sites were replaced with explicit string→atom whitelists in `BDS.BoundedAtoms`. Session restore, LiveView view/tab/route parsing, panel tab parsing, shell command parsing, import sections, taxonomy types, AI endpoints, MCP agents, menu kinds, script kinds, and post/translation status parsing now all use bounded parsers with explicit fallbacks. -**Plan:** introduce explicit string→atom whitelists for the half-dozen call sites (`safe_existing_atom`, view-id parsing, panel-tab parsing) so the rescue clause becomes dead code, then delete it. +**Rule:** user/client/file-provided strings must not be converted with `String.to_existing_atom/1` plus rescue; add a bounded parser for the relevant enum instead. --- @@ -216,6 +216,8 @@ Most tests share the SQLite repo and named GenServers (`BDS.Tasks`, `BDS.Search` ### 2026-05-01 +- **`String.to_existing_atom/1` + rescue**: added `BDS.BoundedAtoms` as the shared bounded string→atom parser for sidebar views, editor routes, panel tabs, post statuses, translation statuses, script/template/menu kinds, import sections, taxonomy types, AI endpoints, MCP agents, and shell commands. Replaced every `String.to_existing_atom/1` call site and removed the `safe_existing_atom` rescue helpers. Added regression coverage that scans `lib/**/*.ex` to prevent reintroducing `String.to_existing_atom/1` outside the bounded parser module. Section 8 is closed. + - **Direct `Repo.get` in `BDS.Desktop.ShellLive`**: added context helpers for primary-key reads (`Posts.get_post/1`, `Media.get_media/1`, `Templates.get_template/1`, `Scripts.get_script/1`, `AI.get_chat_conversation/1`) and introduced `BDS.Settings` for global editor settings. Replaced all ShellLive `Repo.get/2` and `Repo.get!/2` calls across the main shell, tab helpers, CLI sync, panel renderer, chat message build, code entity editor, post editor, media editor, overlay components, post metadata, and settings editor. Added a ShellLive regression test that scans source files to keep direct `Repo.get` calls out. Section 7 is closed. - **God modules**: diff --git a/lib/bds/bounded_atoms.ex b/lib/bds/bounded_atoms.ex new file mode 100644 index 0000000..4c0b049 --- /dev/null +++ b/lib/bds/bounded_atoms.ex @@ -0,0 +1,88 @@ +defmodule BDS.BoundedAtoms do + @moduledoc false + + alias BDS.UI.Registry + + @panel_tabs [:tasks, :output, :post_links, :git_log] + @post_statuses [:draft, :published, :archived] + @translation_statuses [:draft, :published] + @script_kinds [:macro, :utility, :transform] + @template_kinds [:post, :list, :not_found, :partial] + @menu_kinds [:page, :submenu, :category_archive, :home] + @import_sections [ + :post_conflicts, + :page_conflicts, + :posts, + :other, + :pages, + :media, + :taxonomy, + :macros + ] + @taxonomy_types [:categories, :tags] + @ai_endpoints [:online, :airplane] + @mcp_agents [ + :claude_code, + :claude_desktop, + :github_copilot, + :gemini_cli, + :opencode, + :mistral_vibe, + :openai_codex + ] + @shell_commands [ + :toggle_sidebar, + :toggle_panel, + :toggle_assistant_sidebar, + :view_posts, + :view_media, + :edit_preferences, + :edit_menu, + :documentation, + :api_documentation, + :close_tab + ] + + def atom(value, allowed, fallback \\ nil) + + def atom(value, allowed, fallback) when is_atom(value) do + if value in allowed, do: value, else: fallback + end + + def atom(value, allowed, fallback) when is_binary(value), + do: string_atom(value, allowed, fallback) + + def atom(_value, _allowed, fallback), do: fallback + + def sidebar_view(value, fallback \\ nil), do: atom(value, sidebar_views(), fallback) + def editor_route(value, fallback \\ nil), do: atom(value, editor_routes(), fallback) + def panel_tab(value, fallback \\ nil), do: atom(value, @panel_tabs, fallback) + def post_status(value, fallback \\ nil), do: atom(value, @post_statuses, fallback) + def translation_status(value, fallback \\ nil), do: atom(value, @translation_statuses, fallback) + def script_kind(value, fallback \\ nil), do: atom(value, @script_kinds, fallback) + def template_kind(value, fallback \\ nil), do: atom(value, @template_kinds, fallback) + + def menu_kind(value, fallback \\ nil), + do: atom(normalize_menu_kind(value), @menu_kinds, fallback) + + def import_section(value, fallback \\ nil), do: atom(value, @import_sections, fallback) + def taxonomy_type(value, fallback \\ nil), do: atom(value, @taxonomy_types, fallback) + def ai_endpoint(value, fallback \\ nil), do: atom(value, @ai_endpoints, fallback) + def mcp_agent(value, fallback \\ nil), do: atom(value, @mcp_agents, fallback) + def shell_command(value, fallback \\ nil), do: atom(value, @shell_commands, fallback) + + defp string_atom(value, allowed, fallback) do + Enum.find(allowed, fallback, &(Atom.to_string(&1) == value)) + end + + defp sidebar_views do + Enum.map(Registry.sidebar_views(), & &1.id) + end + + defp editor_routes do + Enum.map(Registry.editor_routes(), & &1.id) + end + + defp normalize_menu_kind("category-archive"), do: "category_archive" + defp normalize_menu_kind(value), do: value +end diff --git a/lib/bds/desktop/shell_live.ex b/lib/bds/desktop/shell_live.ex index 973e752..3128503 100644 --- a/lib/bds/desktop/shell_live.ex +++ b/lib/bds/desktop/shell_live.ex @@ -5,20 +5,44 @@ defmodule BDS.Desktop.ShellLive do import Phoenix.HTML - alias BDS.AI + alias BDS.{AI, BoundedAtoms} alias BDS.CliSync.Watcher alias BDS.Desktop.{FolderPicker, Overlay, ShellData, UILocale} - alias BDS.Desktop.ShellLive.{ChatEditor, CodeEntityEditor, ImportEditor, MediaEditor, MenuEditor, MiscEditor, SettingsEditor, TagsEditor} + + alias BDS.Desktop.ShellLive.{ + ChatEditor, + CodeEntityEditor, + ImportEditor, + MediaEditor, + MenuEditor, + MiscEditor, + SettingsEditor, + TagsEditor + } + alias BDS.Desktop.ShellLive.OverlayComponents, as: ShellOverlayComponents alias BDS.Desktop.ShellLive.PostEditor alias BDS.Desktop.ShellLive.SidebarComponents, as: ShellSidebarComponents alias BDS.Desktop.ShellLive.SidebarState, as: ShellSidebarState - alias BDS.Desktop.ShellLive.{ChatSurface, CliSync, Layout, SessionUtil, ShellCommandRunner, SidebarCreate, TabHelpers, TaskLocalization, TitlebarMenu} + + alias BDS.Desktop.ShellLive.{ + ChatSurface, + CliSync, + Layout, + SessionUtil, + ShellCommandRunner, + SidebarCreate, + TabHelpers, + TaskLocalization, + TitlebarMenu + } + import TaskLocalization, only: [ localize_task_status: 2, translate_for_socket: 2 ] + import TabHelpers, only: [ tab_title: 2, @@ -28,6 +52,7 @@ defmodule BDS.Desktop.ShellLive do sidebar_route_atom: 1, parse_integer: 1 ] + alias BDS.Projects alias BDS.Templates alias BDS.UI.{Commands, MenuBar, Session, Workbench} @@ -35,19 +60,19 @@ defmodule BDS.Desktop.ShellLive do @refresh_interval 1_500 @output_entry_limit 20 @local_menu_actions MapSet.new([ - :toggle_sidebar, - :toggle_panel, - :toggle_assistant_sidebar, - :view_posts, - :view_media, - :edit_preferences, - :edit_menu, - :documentation, - :api_documentation, - :close_tab - ]) + :toggle_sidebar, + :toggle_panel, + :toggle_assistant_sidebar, + :view_posts, + :view_media, + :edit_preferences, + :edit_menu, + :documentation, + :api_documentation, + :close_tab + ]) - embed_templates "shell_live/*" + embed_templates("shell_live/*") @impl true def mount(_params, _session, socket) do @@ -64,67 +89,67 @@ defmodule BDS.Desktop.ShellLive do socket |> assign(:page_title, ShellData.title()) |> assign(:page_language, ShellData.ui_language()) - |> assign(:client_shortcuts, Commands.client_shortcuts()) - |> assign(:offline_mode, if(connected, do: AI.airplane_mode?(true), else: true)) - |> assign(:handled_task_results, SessionUtil.initial_handled_task_results()) - |> assign(:assistant_prompt, "") - |> assign(:assistant_messages, []) - |> assign(:is_mac_ui, mac_ui?()) - |> assign(:menu_groups, TitlebarMenu.groups()) - |> assign(:titlebar_menu_group, nil) - |> assign(:titlebar_menu_item_index, nil) + |> assign(:client_shortcuts, Commands.client_shortcuts()) + |> assign(:offline_mode, if(connected, do: AI.airplane_mode?(true), else: true)) + |> assign(:handled_task_results, SessionUtil.initial_handled_task_results()) + |> assign(:assistant_prompt, "") + |> assign(:assistant_messages, []) + |> assign(:is_mac_ui, mac_ui?()) + |> assign(:menu_groups, TitlebarMenu.groups()) + |> assign(:titlebar_menu_group, nil) + |> assign(:titlebar_menu_item_index, nil) |> assign(:tab_meta, %{}) - |> assign(:project_menu_open, false) - |> assign(:sidebar_filters_by_view, %{}) - |> assign(:sidebar_filter_panels, %{}) - |> assign(:post_editor_drafts, %{}) - |> assign(:post_editor_active_languages, %{}) - |> assign(:post_editor_tag_queries, %{}) - |> assign(:post_editor_category_queries, %{}) - |> assign(:post_editor_quick_actions_open, %{}) - |> assign(:post_editor_modes, %{}) - |> assign(:post_editor_expanded, %{}) - |> assign(:post_editor_save_states, %{}) - |> assign(:media_editor_drafts, %{}) - |> assign(:media_editor_quick_actions_open, %{}) - |> assign(:media_editor_post_pickers_open, %{}) - |> assign(:media_editor_post_picker_queries, %{}) - |> assign(:media_editor_save_states, %{}) - |> assign(:media_editor_translation_forms, %{}) - |> assign(:settings_editor_search, "") - |> assign(:settings_editor_project_draft, %{}) - |> assign(:settings_editor_endpoint_models, %{}) - |> assign(:settings_editor_publishing_draft, %{}) - |> assign(:settings_editor_new_category, "") - |> assign(:style_editor_theme, nil) - |> assign(:style_editor_preview_mode, "auto") - |> assign(:tags_editor_selected, []) - |> assign(:tags_editor_new_tag, %{"name" => "", "color" => ""}) - |> assign(:tags_editor_edit_draft, %{}) - |> assign(:tags_editor_merge_target, "") - |> assign(:script_editor_drafts, %{}) - |> assign(:template_editor_drafts, %{}) - |> assign(:chat_editor_inputs, %{}) - |> assign(:chat_model_selectors_open, %{}) - |> assign(:chat_editor_requests, %{}) - |> assign(:chat_editor_request_refs, %{}) - |> assign(:chat_editor_surface_data, %{}) - |> assign(:chat_editor_surface_tabs, %{}) - |> assign(:chat_editor_action_errors, %{}) - |> assign(:import_editor_analysis_states, %{}) - |> assign(:import_editor_analysis_task_refs, %{}) - |> assign(:import_editor_execution_states, %{}) - |> assign(:import_editor_execution_task_refs, %{}) - |> assign(:import_editor_sections, %{}) - |> assign(:import_editor_taxonomy_edits, %{}) - |> assign(:import_editor_model_selectors_open, %{}) - |> assign(:import_editor_selected_models, %{}) - |> assign(:misc_editor_selected_pairs, %{}) - |> assign(:misc_editor_git_selected_files, %{}) - |> assign(:metadata_diff_active_tabs, %{}) - |> assign(:metadata_diff_field_filters, %{}) - |> assign(:shell_overlay, nil) - |> assign(:output_entries, []) + |> assign(:project_menu_open, false) + |> assign(:sidebar_filters_by_view, %{}) + |> assign(:sidebar_filter_panels, %{}) + |> assign(:post_editor_drafts, %{}) + |> assign(:post_editor_active_languages, %{}) + |> assign(:post_editor_tag_queries, %{}) + |> assign(:post_editor_category_queries, %{}) + |> assign(:post_editor_quick_actions_open, %{}) + |> assign(:post_editor_modes, %{}) + |> assign(:post_editor_expanded, %{}) + |> assign(:post_editor_save_states, %{}) + |> assign(:media_editor_drafts, %{}) + |> assign(:media_editor_quick_actions_open, %{}) + |> assign(:media_editor_post_pickers_open, %{}) + |> assign(:media_editor_post_picker_queries, %{}) + |> assign(:media_editor_save_states, %{}) + |> assign(:media_editor_translation_forms, %{}) + |> assign(:settings_editor_search, "") + |> assign(:settings_editor_project_draft, %{}) + |> assign(:settings_editor_endpoint_models, %{}) + |> assign(:settings_editor_publishing_draft, %{}) + |> assign(:settings_editor_new_category, "") + |> assign(:style_editor_theme, nil) + |> assign(:style_editor_preview_mode, "auto") + |> assign(:tags_editor_selected, []) + |> assign(:tags_editor_new_tag, %{"name" => "", "color" => ""}) + |> assign(:tags_editor_edit_draft, %{}) + |> assign(:tags_editor_merge_target, "") + |> assign(:script_editor_drafts, %{}) + |> assign(:template_editor_drafts, %{}) + |> assign(:chat_editor_inputs, %{}) + |> assign(:chat_model_selectors_open, %{}) + |> assign(:chat_editor_requests, %{}) + |> assign(:chat_editor_request_refs, %{}) + |> assign(:chat_editor_surface_data, %{}) + |> assign(:chat_editor_surface_tabs, %{}) + |> assign(:chat_editor_action_errors, %{}) + |> assign(:import_editor_analysis_states, %{}) + |> assign(:import_editor_analysis_task_refs, %{}) + |> assign(:import_editor_execution_states, %{}) + |> assign(:import_editor_execution_task_refs, %{}) + |> assign(:import_editor_sections, %{}) + |> assign(:import_editor_taxonomy_edits, %{}) + |> assign(:import_editor_model_selectors_open, %{}) + |> assign(:import_editor_selected_models, %{}) + |> assign(:misc_editor_selected_pairs, %{}) + |> assign(:misc_editor_git_selected_files, %{}) + |> assign(:metadata_diff_active_tabs, %{}) + |> assign(:metadata_diff_field_filters, %{}) + |> assign(:shell_overlay, nil) + |> assign(:output_entries, []) |> reload_shell(workbench)} end @@ -142,7 +167,12 @@ defmodule BDS.Desktop.ShellLive do end def handle_event("select_view", %{"view" => view_id}, socket) do - workbench = Workbench.click_activity(socket.assigns.workbench, String.to_existing_atom(view_id)) + workbench = + Workbench.click_activity( + socket.assigns.workbench, + BoundedAtoms.sidebar_view(view_id, :posts) + ) + {:noreply, reload_shell(socket, workbench)} end @@ -150,7 +180,7 @@ defmodule BDS.Desktop.ShellLive do workbench = socket.assigns.workbench |> Workbench.set_panel_visible(true) - |> Workbench.set_panel_tab(String.to_existing_atom(tab)) + |> Workbench.set_panel_tab(BoundedAtoms.panel_tab(tab, :tasks)) {:noreply, reload_shell(socket, workbench)} end @@ -177,7 +207,13 @@ defmodule BDS.Desktop.ShellLive do if state.visible do %{state | visible: false} else - %{visible: true, archive_collapsed: true, tags_collapsed: true, categories_collapsed: true, expanded_year: nil} + %{ + visible: true, + archive_collapsed: true, + tags_collapsed: true, + categories_collapsed: true, + expanded_year: nil + } end end) @@ -189,63 +225,79 @@ defmodule BDS.Desktop.ShellLive do def handle_event("toggle_sidebar_archive", _params, socket) do {:noreply, socket - |> ShellSidebarState.put_filter_panel_state(fn state -> %{state | archive_collapsed: not state.archive_collapsed} end) + |> ShellSidebarState.put_filter_panel_state(fn state -> + %{state | archive_collapsed: not state.archive_collapsed} + end) |> reload_shell(socket.assigns.workbench)} end def handle_event("toggle_sidebar_tags", _params, socket) do {:noreply, socket - |> ShellSidebarState.put_filter_panel_state(fn state -> %{state | tags_collapsed: not state.tags_collapsed} end) + |> ShellSidebarState.put_filter_panel_state(fn state -> + %{state | tags_collapsed: not state.tags_collapsed} + end) |> reload_shell(socket.assigns.workbench)} end def handle_event("toggle_sidebar_categories", _params, socket) do {:noreply, socket - |> ShellSidebarState.put_filter_panel_state(fn state -> %{state | categories_collapsed: not state.categories_collapsed} end) + |> ShellSidebarState.put_filter_panel_state(fn state -> + %{state | categories_collapsed: not state.categories_collapsed} + end) |> reload_shell(socket.assigns.workbench)} end def handle_event("update_sidebar_search", %{"sidebar_filters" => params}, socket) do {:noreply, socket - |> ShellSidebarState.put_filters(fn filters -> Map.put(filters, :search, ShellSidebarState.normalize_filter_string(Map.get(params, "search"))) end) + |> ShellSidebarState.put_filters(fn filters -> + Map.put( + filters, + :search, + ShellSidebarState.normalize_filter_string(Map.get(params, "search")) + ) + end) |> reload_shell(socket.assigns.workbench)} end def handle_event("clear_sidebar_search", _params, socket) do {:noreply, socket - |> ShellSidebarState.put_filters(fn filters -> Map.put(filters, :search, nil) end) + |> ShellSidebarState.put_filters(fn filters -> Map.put(filters, :search, nil) end) |> reload_shell(socket.assigns.workbench)} end def handle_event("clear_sidebar_tags", _params, socket) do {:noreply, socket - |> ShellSidebarState.put_filters(fn filters -> Map.put(filters, :tags, []) end) + |> ShellSidebarState.put_filters(fn filters -> Map.put(filters, :tags, []) end) |> reload_shell(socket.assigns.workbench)} end def handle_event("clear_sidebar_categories", _params, socket) do {:noreply, socket - |> ShellSidebarState.put_filters(fn filters -> Map.put(filters, :categories, []) end) + |> ShellSidebarState.put_filters(fn filters -> Map.put(filters, :categories, []) end) |> reload_shell(socket.assigns.workbench)} end def handle_event("toggle_sidebar_tag", %{"tag" => tag}, socket) do {:noreply, socket - |> ShellSidebarState.put_filters(fn filters -> ShellSidebarState.toggle_filter_value(filters, :tags, tag) end) + |> ShellSidebarState.put_filters(fn filters -> + ShellSidebarState.toggle_filter_value(filters, :tags, tag) + end) |> reload_shell(socket.assigns.workbench)} end def handle_event("toggle_sidebar_category", %{"category" => category}, socket) do {:noreply, socket - |> ShellSidebarState.put_filters(fn filters -> ShellSidebarState.toggle_filter_value(filters, :categories, category) end) + |> ShellSidebarState.put_filters(fn filters -> + ShellSidebarState.toggle_filter_value(filters, :categories, category) + end) |> reload_shell(socket.assigns.workbench)} end @@ -255,9 +307,10 @@ defmodule BDS.Desktop.ShellLive do {:noreply, socket |> ShellSidebarState.put_filter_panel_state(fn state -> - %{state | - archive_collapsed: false, - expanded_year: if(state.expanded_year == parsed_year, do: nil, else: parsed_year) + %{ + state + | archive_collapsed: false, + expanded_year: if(state.expanded_year == parsed_year, do: nil, else: parsed_year) } end) |> ShellSidebarState.put_filters(fn filters -> @@ -272,7 +325,11 @@ defmodule BDS.Desktop.ShellLive do {:noreply, socket |> ShellSidebarState.put_filter_panel_state(fn state -> - %{state | archive_collapsed: false, expanded_year: ShellSidebarState.parse_optional_integer(year)} + %{ + state + | archive_collapsed: false, + expanded_year: ShellSidebarState.parse_optional_integer(year) + } end) |> ShellSidebarState.put_filters(fn filters -> filters @@ -285,8 +342,12 @@ defmodule BDS.Desktop.ShellLive do def handle_event("clear_sidebar_month", _params, socket) do {:noreply, socket - |> ShellSidebarState.put_filter_panel_state(fn state -> %{state | archive_collapsed: false} end) - |> ShellSidebarState.put_filters(fn filters -> filters |> Map.put(:year, nil) |> Map.put(:month, nil) end) + |> ShellSidebarState.put_filter_panel_state(fn state -> + %{state | archive_collapsed: false} + end) + |> ShellSidebarState.put_filters(fn filters -> + filters |> Map.put(:year, nil) |> Map.put(:month, nil) + end) |> reload_shell(socket.assigns.workbench)} end @@ -300,7 +361,10 @@ defmodule BDS.Desktop.ShellLive do |> Map.put(:month, nil) |> Map.put(:tags, []) |> Map.put(:categories, []) - |> Map.put(:display_limit, ShellSidebarState.sidebar_page_size(socket.assigns.sidebar_data)) + |> Map.put( + :display_limit, + ShellSidebarState.sidebar_page_size(socket.assigns.sidebar_data) + ) end) |> reload_shell(socket.assigns.workbench)} end @@ -309,7 +373,12 @@ defmodule BDS.Desktop.ShellLive do {:noreply, socket |> ShellSidebarState.put_filters(fn filters -> - Map.update(filters, :display_limit, ShellSidebarState.sidebar_page_size(socket.assigns.sidebar_data), &(&1 + ShellSidebarState.sidebar_page_size(socket.assigns.sidebar_data))) + Map.update( + filters, + :display_limit, + ShellSidebarState.sidebar_page_size(socket.assigns.sidebar_data), + &(&1 + ShellSidebarState.sidebar_page_size(socket.assigns.sidebar_data)) + ) end) |> reload_shell(socket.assigns.workbench)} end @@ -328,13 +397,18 @@ defmodule BDS.Desktop.ShellLive do def handle_event("select_tab", %{"type" => type, "id" => id}, socket) do workbench = - Workbench.open_tab(socket.assigns.workbench, String.to_existing_atom(type), id, :preview) + Workbench.open_tab( + socket.assigns.workbench, + BoundedAtoms.editor_route(type, :post), + id, + :preview + ) {:noreply, reload_shell(socket, workbench)} end def handle_event("close_tab", %{"type" => type, "id" => id}, socket) do - type_atom = String.to_existing_atom(type) + type_atom = BoundedAtoms.editor_route(type, :post) workbench = Workbench.close_tab(socket.assigns.workbench, type_atom, id) tab_meta = Map.delete(socket.assigns.tab_meta, {type_atom, id}) @@ -346,7 +420,8 @@ defmodule BDS.Desktop.ShellLive do def handle_event("delete_sidebar_template", %{"id" => template_id}, socket) do case Templates.get_template(template_id) do - %Templates.Template{project_id: project_id} when project_id == socket.assigns.projects.active_project_id -> + %Templates.Template{project_id: project_id} + when project_id == socket.assigns.projects.active_project_id -> case Templates.delete_template(template_id) do {:ok, :deleted} -> workbench = Workbench.close_tab(socket.assigns.workbench, :templates, template_id) @@ -360,14 +435,24 @@ defmodule BDS.Desktop.ShellLive do {:error, reason} -> {:noreply, socket - |> append_output_entry(translated("Delete") <> " " <> translated("Template"), inspect(reason), nil, "error") + |> append_output_entry( + translated("Delete") <> " " <> translated("Template"), + inspect(reason), + nil, + "error" + ) |> reload_shell(socket.assigns.workbench)} end _other -> {:noreply, socket - |> append_output_entry(translated("Delete") <> " " <> translated("Template"), inspect(:not_found), nil, "error") + |> append_output_entry( + translated("Delete") <> " " <> translated("Template"), + inspect(:not_found), + nil, + "error" + ) |> reload_shell(socket.assigns.workbench)} end end @@ -394,7 +479,10 @@ defmodule BDS.Desktop.ShellLive do else socket |> assign(:assistant_prompt, "") - |> assign(:assistant_messages, socket.assigns.assistant_messages ++ ChatSurface.assistant_turn(prompt, socket)) + |> assign( + :assistant_messages, + socket.assigns.assistant_messages ++ ChatSurface.assistant_turn(prompt, socket) + ) end {:noreply, socket} @@ -414,15 +502,18 @@ defmodule BDS.Desktop.ShellLive do end def handle_event("save_post_editor", %{"id" => post_id}, socket) do - {:noreply, PostEditor.persist_socket(socket, post_id, :save, &reload_shell/2, &append_output_entry/5)} + {:noreply, + PostEditor.persist_socket(socket, post_id, :save, &reload_shell/2, &append_output_entry/5)} end def handle_event("publish_post_editor", %{"id" => post_id}, socket) do - {:noreply, PostEditor.persist_socket(socket, post_id, :publish, &reload_shell/2, &append_output_entry/5)} + {:noreply, + PostEditor.persist_socket(socket, post_id, :publish, &reload_shell/2, &append_output_entry/5)} end def handle_event("discard_post_editor", %{"id" => post_id}, socket) do - {:noreply, PostEditor.discard_socket(socket, post_id, &reload_shell/2, &append_output_entry/5)} + {:noreply, + PostEditor.discard_socket(socket, post_id, &reload_shell/2, &append_output_entry/5)} end def handle_event("delete_post_editor", %{"id" => post_id}, socket) do @@ -441,7 +532,11 @@ defmodule BDS.Desktop.ShellLive do {:noreply, PostEditor.toggle_section(socket, post_id, :excerpt, &reload_shell/2)} end - def handle_event("select_post_editor_language", %{"id" => post_id, "language" => language}, socket) do + def handle_event( + "select_post_editor_language", + %{"id" => post_id, "language" => language}, + socket + ) do {:noreply, PostEditor.select_language(socket, post_id, language, &reload_shell/2)} end @@ -450,7 +545,8 @@ defmodule BDS.Desktop.ShellLive do end def handle_event("detect_post_editor_language", %{"id" => post_id}, socket) do - {:noreply, PostEditor.detect_language(socket, post_id, &reload_shell/2, &append_output_entry/5)} + {:noreply, + PostEditor.detect_language(socket, post_id, &reload_shell/2, &append_output_entry/5)} end def handle_event("add_post_editor_tag", %{"id" => post_id, "tag" => tag}, socket) do @@ -465,8 +561,13 @@ defmodule BDS.Desktop.ShellLive do {:noreply, PostEditor.add_list_value(socket, post_id, :categories, category, &reload_shell/2)} end - def handle_event("remove_post_editor_category", %{"id" => post_id, "category" => category}, socket) do - {:noreply, PostEditor.remove_list_value(socket, post_id, :categories, category, &reload_shell/2)} + def handle_event( + "remove_post_editor_category", + %{"id" => post_id, "category" => category}, + socket + ) do + {:noreply, + PostEditor.remove_list_value(socket, post_id, :categories, category, &reload_shell/2)} end def handle_event("change_media_editor", %{"media_editor" => params}, socket) do @@ -474,7 +575,8 @@ defmodule BDS.Desktop.ShellLive do end def handle_event("save_media_editor", %{"id" => media_id}, socket) do - {:noreply, MediaEditor.persist_socket(socket, media_id, &reload_shell/2, &append_output_entry/5)} + {:noreply, + MediaEditor.persist_socket(socket, media_id, &reload_shell/2, &append_output_entry/5)} end def handle_event("toggle_media_editor_quick_actions", %{"id" => media_id}, socket) do @@ -482,27 +584,35 @@ defmodule BDS.Desktop.ShellLive do end def handle_event("replace_media_editor_file", %{"id" => media_id}, socket) do - {:noreply, MediaEditor.replace_file(socket, media_id, &reload_shell/2, &append_output_entry/5)} + {:noreply, + MediaEditor.replace_file(socket, media_id, &reload_shell/2, &append_output_entry/5)} end def handle_event("detect_media_editor_language", %{"id" => media_id}, socket) do - {:noreply, MediaEditor.detect_language(socket, media_id, &reload_shell/2, &append_output_entry/5)} + {:noreply, + MediaEditor.detect_language(socket, media_id, &reload_shell/2, &append_output_entry/5)} end def handle_event("toggle_media_post_picker", %{"id" => media_id}, socket) do {:noreply, MediaEditor.toggle_post_picker(socket, media_id, &reload_shell/2)} end - def handle_event("change_media_post_picker", %{"id" => media_id, "media_post_picker" => %{"query" => query}}, socket) do + def handle_event( + "change_media_post_picker", + %{"id" => media_id, "media_post_picker" => %{"query" => query}}, + socket + ) do {:noreply, MediaEditor.set_post_picker_query(socket, media_id, query, &reload_shell/2)} end def handle_event("link_media_to_post", %{"id" => media_id, "post-id" => post_id}, socket) do - {:noreply, MediaEditor.link_post(socket, media_id, post_id, &reload_shell/2, &append_output_entry/5)} + {:noreply, + MediaEditor.link_post(socket, media_id, post_id, &reload_shell/2, &append_output_entry/5)} end def handle_event("unlink_media_from_post", %{"id" => media_id, "post-id" => post_id}, socket) do - {:noreply, MediaEditor.unlink_post(socket, media_id, post_id, &reload_shell/2, &append_output_entry/5)} + {:noreply, + MediaEditor.unlink_post(socket, media_id, post_id, &reload_shell/2, &append_output_entry/5)} end def handle_event("edit_media_translation", %{"id" => media_id, "language" => language}, socket) do @@ -511,21 +621,47 @@ defmodule BDS.Desktop.ShellLive do def handle_event("change_media_translation", %{"media_translation" => params}, socket) do case socket.assigns.current_tab do - %{type: :media, id: media_id} -> {:noreply, MediaEditor.update_translation(socket, media_id, params, &reload_shell/2)} - _other -> {:noreply, socket} + %{type: :media, id: media_id} -> + {:noreply, MediaEditor.update_translation(socket, media_id, params, &reload_shell/2)} + + _other -> + {:noreply, socket} end end def handle_event("save_media_translation", %{"id" => media_id}, socket) do - {:noreply, MediaEditor.save_translation(socket, media_id, &reload_shell/2, &append_output_entry/5)} + {:noreply, + MediaEditor.save_translation(socket, media_id, &reload_shell/2, &append_output_entry/5)} end - def handle_event("refresh_media_translation", %{"id" => media_id, "language" => language}, socket) do - {:noreply, MediaEditor.refresh_translation(socket, media_id, language, &reload_shell/2, &append_output_entry/5)} + def handle_event( + "refresh_media_translation", + %{"id" => media_id, "language" => language}, + socket + ) do + {:noreply, + MediaEditor.refresh_translation( + socket, + media_id, + language, + &reload_shell/2, + &append_output_entry/5 + )} end - def handle_event("delete_media_translation", %{"id" => media_id, "language" => language}, socket) do - {:noreply, MediaEditor.delete_translation(socket, media_id, language, &reload_shell/2, &append_output_entry/5)} + def handle_event( + "delete_media_translation", + %{"id" => media_id, "language" => language}, + socket + ) do + {:noreply, + MediaEditor.delete_translation( + socket, + media_id, + language, + &reload_shell/2, + &append_output_entry/5 + )} end def handle_event("close_media_translation_editor", _params, socket) do @@ -533,7 +669,10 @@ defmodule BDS.Desktop.ShellLive do %{type: :media, id: media_id} -> {:noreply, socket - |> assign(:media_editor_translation_forms, Map.delete(socket.assigns.media_editor_translation_forms, media_id)) + |> assign( + :media_editor_translation_forms, + Map.delete(socket.assigns.media_editor_translation_forms, media_id) + ) |> reload_shell(socket.assigns.workbench)} _other -> @@ -570,8 +709,19 @@ defmodule BDS.Desktop.ShellLive do end def handle_event("refresh_settings_ai_models", %{"endpoint" => endpoint}, socket) do - endpoint_key = String.to_existing_atom(endpoint) - {:noreply, SettingsEditor.refresh_ai_models(socket, endpoint_key, &reload_shell/2, &append_output_entry/5)} + case BoundedAtoms.ai_endpoint(endpoint) do + nil -> + {:noreply, reload_shell(socket, socket.assigns.workbench)} + + endpoint_key -> + {:noreply, + SettingsEditor.refresh_ai_models( + socket, + endpoint_key, + &reload_shell/2, + &append_output_entry/5 + )} + end end def handle_event("save_settings_ai", _params, socket) do @@ -603,11 +753,13 @@ defmodule BDS.Desktop.ShellLive do end def handle_event("save_settings_category", %{"category_settings" => params}, socket) do - {:noreply, SettingsEditor.save_category(socket, params, &reload_shell/2, &append_output_entry/5)} + {:noreply, + SettingsEditor.save_category(socket, params, &reload_shell/2, &append_output_entry/5)} end def handle_event("remove_settings_category", %{"category" => category}, socket) do - {:noreply, SettingsEditor.remove_category(socket, category, &reload_shell/2, &append_output_entry/5)} + {:noreply, + SettingsEditor.remove_category(socket, category, &reload_shell/2, &append_output_entry/5)} end def handle_event("settings_shell_command", %{"action" => action}, socket) do @@ -615,7 +767,8 @@ defmodule BDS.Desktop.ShellLive do end def handle_event("toggle_settings_mcp_agent", %{"agent" => agent}, socket) do - {:noreply, SettingsEditor.toggle_mcp_agent(socket, agent, &reload_shell/2, &append_output_entry/5)} + {:noreply, + SettingsEditor.toggle_mcp_agent(socket, agent, &reload_shell/2, &append_output_entry/5)} end def handle_event("select_style_theme", %{"theme" => theme}, socket) do @@ -660,10 +813,15 @@ defmodule BDS.Desktop.ShellLive do def handle_event( "menu_editor_drop_item", - %{"drag_item_id" => drag_item_id, "target_item_id" => target_item_id, "position" => position}, + %{ + "drag_item_id" => drag_item_id, + "target_item_id" => target_item_id, + "position" => position + }, socket ) do - {:noreply, MenuEditor.drop_item(socket, drag_item_id, target_item_id, position, &reload_shell/2)} + {:noreply, + MenuEditor.drop_item(socket, drag_item_id, target_item_id, position, &reload_shell/2)} end def handle_event("menu_editor_keydown", %{"key" => key}, socket) do @@ -735,7 +893,8 @@ defmodule BDS.Desktop.ShellLive do end def handle_event("validate_template_editor", _params, socket) do - {:noreply, CodeEntityEditor.validate_template(socket, &reload_shell/2, &append_output_entry/5)} + {:noreply, + CodeEntityEditor.validate_template(socket, &reload_shell/2, &append_output_entry/5)} end def handle_event("delete_template_editor", _params, socket) do @@ -766,15 +925,27 @@ defmodule BDS.Desktop.ShellLive do {:noreply, socket |> ChatSurface.clear_action_error() - |> open_sidebar_item(%{"route" => "settings", "id" => "settings-ai", "title" => "Settings", "subtitle" => "AI"}, :pin)} + |> open_sidebar_item( + %{"route" => "settings", "id" => "settings-ai", "title" => "Settings", "subtitle" => "AI"}, + :pin + )} end - def handle_event("change_chat_surface_form", %{"surface" => %{"id" => surface_id, "fields" => fields}}, socket) do + def handle_event( + "change_chat_surface_form", + %{"surface" => %{"id" => surface_id, "fields" => fields}}, + socket + ) do {:noreply, ChatEditor.update_surface_form(socket, surface_id, fields, &reload_shell/2)} end - def handle_event("select_chat_surface_tab", %{"surface-id" => surface_id, "index" => index}, socket) do - {:noreply, ChatEditor.select_surface_tab(socket, surface_id, parse_integer(index), &reload_shell/2)} + def handle_event( + "select_chat_surface_tab", + %{"surface-id" => surface_id, "index" => index}, + socket + ) do + {:noreply, + ChatEditor.select_surface_tab(socket, surface_id, parse_integer(index), &reload_shell/2)} end def handle_event("chat_surface_action", params, socket) do @@ -790,7 +961,8 @@ defmodule BDS.Desktop.ShellLive do end def handle_event("select_import_uploads_folder", _params, socket) do - {:noreply, ImportEditor.select_uploads_folder(socket, &reload_shell/2, &append_output_entry/5)} + {:noreply, + ImportEditor.select_uploads_folder(socket, &reload_shell/2, &append_output_entry/5)} end def handle_event("select_import_wxr_file", _params, socket) do @@ -853,8 +1025,11 @@ defmodule BDS.Desktop.ShellLive do def handle_event("fix_translation_validation", _params, socket) do case MiscEditor.fix_translation_validation(socket, &append_output_entry/5) do - {:rerun, next_socket} -> {:noreply, apply_shell_command(next_socket, "validate_translations")} - {:socket, next_socket} -> {:noreply, next_socket} + {:rerun, next_socket} -> + {:noreply, apply_shell_command(next_socket, "validate_translations")} + + {:socket, next_socket} -> + {:noreply, next_socket} end end @@ -866,8 +1041,19 @@ defmodule BDS.Desktop.ShellLive do {:noreply, MiscEditor.toggle_duplicate(socket, pair_id, &reload_shell/2)} end - def handle_event("dismiss_duplicate_pair", %{"post-id-a" => post_id_a, "post-id-b" => post_id_b}, socket) do - {:noreply, MiscEditor.dismiss_duplicate(socket, post_id_a, post_id_b, &reload_shell/2, &append_output_entry/5)} + def handle_event( + "dismiss_duplicate_pair", + %{"post-id-a" => post_id_a, "post-id-b" => post_id_b}, + socket + ) do + {:noreply, + MiscEditor.dismiss_duplicate( + socket, + post_id_a, + post_id_b, + &reload_shell/2, + &append_output_entry/5 + )} end def handle_event("dismiss_selected_duplicates", _params, socket) do @@ -876,15 +1062,35 @@ defmodule BDS.Desktop.ShellLive do def handle_event("repair_metadata_diff", %{"field" => field, "direction" => direction}, socket) do case MiscEditor.metadata_diff_repair_request(socket, field, direction) do - {:ok, params} -> {:noreply, apply_shell_command(socket, "repair_metadata_diff", params)} - {:error, message} -> {:noreply, append_output_entry(socket, translate_for_socket(socket, "Metadata Diff"), message, nil, "error")} + {:ok, params} -> + {:noreply, apply_shell_command(socket, "repair_metadata_diff", params)} + + {:error, message} -> + {:noreply, + append_output_entry( + socket, + translate_for_socket(socket, "Metadata Diff"), + message, + nil, + "error" + )} end end def handle_event("import_metadata_diff_orphans", _params, socket) do case MiscEditor.metadata_diff_orphan_import_request(socket) do - {:ok, params} -> {:noreply, apply_shell_command(socket, "import_metadata_diff_orphans", params)} - {:error, message} -> {:noreply, append_output_entry(socket, translate_for_socket(socket, "Metadata Diff"), message, nil, "error")} + {:ok, params} -> + {:noreply, apply_shell_command(socket, "import_metadata_diff_orphans", params)} + + {:error, message} -> + {:noreply, + append_output_entry( + socket, + translate_for_socket(socket, "Metadata Diff"), + message, + nil, + "error" + )} end end @@ -893,8 +1099,14 @@ defmodule BDS.Desktop.ShellLive do socket = socket - |> assign(:metadata_diff_active_tabs, Map.put(socket.assigns.metadata_diff_active_tabs, tab_id, tab)) - |> assign(:metadata_diff_field_filters, Map.delete(socket.assigns.metadata_diff_field_filters, tab_id)) + |> assign( + :metadata_diff_active_tabs, + Map.put(socket.assigns.metadata_diff_active_tabs, tab_id, tab) + ) + |> assign( + :metadata_diff_field_filters, + Map.delete(socket.assigns.metadata_diff_field_filters, tab_id) + ) |> assign_misc_editor() {:noreply, socket} @@ -911,21 +1123,36 @@ defmodule BDS.Desktop.ShellLive do Map.put(socket.assigns.metadata_diff_field_filters, tab_id, field) end - {:noreply, socket |> assign(:metadata_diff_field_filters, next_filters) |> assign_misc_editor()} + {:noreply, + socket |> assign(:metadata_diff_field_filters, next_filters) |> assign_misc_editor()} end def handle_event("open_duplicate_post", %{"id" => id, "title" => title}, socket) do - {:noreply, open_sidebar_item(socket, %{"route" => "post", "id" => id, "title" => title, "subtitle" => "draft"}, :preview)} + {:noreply, + open_sidebar_item( + socket, + %{"route" => "post", "id" => id, "title" => title, "subtitle" => "draft"}, + :preview + )} end def handle_event("open_overlay", %{"kind" => kind}, socket) do socket = case socket.assigns[:current_tab] do %{type: :post, id: post_id} when kind in ["ai_suggestions", "language_picker"] -> - assign(socket, :post_editor_quick_actions_open, Map.put(socket.assigns.post_editor_quick_actions_open, post_id, false)) + assign( + socket, + :post_editor_quick_actions_open, + Map.put(socket.assigns.post_editor_quick_actions_open, post_id, false) + ) - %{type: :media, id: media_id} when kind in ["ai_suggestions", "language_picker", "confirm_delete"] -> - assign(socket, :media_editor_quick_actions_open, Map.put(socket.assigns.media_editor_quick_actions_open, media_id, false)) + %{type: :media, id: media_id} + when kind in ["ai_suggestions", "language_picker", "confirm_delete"] -> + assign( + socket, + :media_editor_quick_actions_open, + Map.put(socket.assigns.media_editor_quick_actions_open, media_id, false) + ) _other -> socket @@ -937,7 +1164,12 @@ defmodule BDS.Desktop.ShellLive do tab = socket.assigns.current_tab title = tab_title(tab, socket.assigns.tab_meta) subtitle = tab_subtitle(tab, socket.assigns.tab_meta) - Overlay.open(route, overlay_kind, ShellOverlayComponents.context(socket.assigns, title, subtitle)) + + Overlay.open( + route, + overlay_kind, + ShellOverlayComponents.context(socket.assigns, title, subtitle) + ) end {:noreply, assign(socket, :shell_overlay, overlay)} @@ -950,11 +1182,20 @@ defmodule BDS.Desktop.ShellLive do def handle_event("overlay_keydown", %{"key" => key}, socket) do socket = case {socket.assigns[:shell_overlay], key} do - {nil, _other} -> socket - {_overlay, "Escape"} -> assign(socket, :shell_overlay, nil) - {%{kind: :gallery} = overlay, "ArrowLeft"} -> assign(socket, :shell_overlay, Overlay.lightbox_previous(overlay)) - {%{kind: :gallery} = overlay, "ArrowRight"} -> assign(socket, :shell_overlay, Overlay.lightbox_next(overlay)) - _other -> socket + {nil, _other} -> + socket + + {_overlay, "Escape"} -> + assign(socket, :shell_overlay, nil) + + {%{kind: :gallery} = overlay, "ArrowLeft"} -> + assign(socket, :shell_overlay, Overlay.lightbox_previous(overlay)) + + {%{kind: :gallery} = overlay, "ArrowRight"} -> + assign(socket, :shell_overlay, Overlay.lightbox_next(overlay)) + + _other -> + socket end {:noreply, socket} @@ -969,14 +1210,19 @@ defmodule BDS.Desktop.ShellLive do end def handle_event("overlay_set_tab", %{"tab" => tab}, socket) do - {:noreply, update_shell_overlay(socket, &Overlay.set_active_tab(&1, ShellOverlayComponents.tab(tab)))} + {:noreply, + update_shell_overlay(socket, &Overlay.set_active_tab(&1, ShellOverlayComponents.tab(tab)))} end def handle_event("overlay_update_form", %{"overlay" => params}, socket) do socket = socket - |> update_shell_overlay(&Overlay.update_form_value(&1, :external_url, Map.get(params, "url", ""))) - |> update_shell_overlay(&Overlay.update_form_value(&1, :external_text, Map.get(params, "text", ""))) + |> update_shell_overlay( + &Overlay.update_form_value(&1, :external_url, Map.get(params, "url", "")) + ) + |> update_shell_overlay( + &Overlay.update_form_value(&1, :external_text, Map.get(params, "text", "")) + ) {:noreply, socket} end @@ -989,13 +1235,23 @@ defmodule BDS.Desktop.ShellLive do case {overlay, current_tab} do {%{kind: :insert_link}, %{type: :post, id: post_id}} -> case Overlay.insert_link_result(overlay, id) do - nil -> socket - result -> PostEditor.insert_content(socket, post_id, ShellOverlayComponents.markdown_link(result.title, result.canonical_url), &reload_shell/2) + nil -> + socket + + result -> + PostEditor.insert_content( + socket, + post_id, + ShellOverlayComponents.markdown_link(result.title, result.canonical_url), + &reload_shell/2 + ) end {%{kind: :insert_media}, %{type: :post, id: post_id}} -> case Overlay.insert_media_result(overlay, id) do - nil -> socket + nil -> + socket + result -> syntax = if result.is_image do @@ -1051,7 +1307,8 @@ defmodule BDS.Desktop.ShellLive do {%{kind: :language_picker}, %{type: :media, id: media_id}} -> MediaEditor.translate(socket, media_id, code, &reload_shell/2, &append_output_entry/5) - _other -> socket + _other -> + socket end {:noreply, socket} @@ -1121,7 +1378,10 @@ defmodule BDS.Desktop.ShellLive do end def handle_event("select_project", %{"project_id" => project_id}, socket) do - {:noreply, activate_project(socket, project_id, "Select Project", fn project -> "Activated #{project.name}" end)} + {:noreply, + activate_project(socket, project_id, "Select Project", fn project -> + "Activated #{project.name}" + end)} end def handle_event("create_project", _params, socket) do @@ -1129,8 +1389,13 @@ defmodule BDS.Desktop.ShellLive do socket = case Projects.create_project(attrs) do - {:ok, project} -> activate_project(socket, project.id, "New Project", fn created -> "Activated #{created.name}" end) - {:error, reason} -> append_output_entry(socket, "New Project", inspect(reason), nil, "error") + {:ok, project} -> + activate_project(socket, project.id, "New Project", fn created -> + "Activated #{created.name}" + end) + + {:error, reason} -> + append_output_entry(socket, "New Project", inspect(reason), nil, "error") end {:noreply, socket} @@ -1140,18 +1405,30 @@ defmodule BDS.Desktop.ShellLive do socket = case FolderPicker.choose_directory("Open Existing Blog") do {:ok, path} -> - name = path |> Path.basename() |> String.trim() |> case do - "" -> "Imported Blog" - value -> value - end + name = + path + |> Path.basename() + |> String.trim() + |> case do + "" -> "Imported Blog" + value -> value + end case Projects.create_project(%{name: name, data_path: path}) do - {:ok, project} -> activate_project(socket, project.id, "Open Existing Blog", fn imported -> "Activated #{imported.name}" end) - {:error, reason} -> append_output_entry(socket, "Open Existing Blog", inspect(reason), nil, "error") + {:ok, project} -> + activate_project(socket, project.id, "Open Existing Blog", fn imported -> + "Activated #{imported.name}" + end) + + {:error, reason} -> + append_output_entry(socket, "Open Existing Blog", inspect(reason), nil, "error") end - :cancel -> assign(socket, :project_menu_open, false) - {:error, %{message: message}} -> append_output_entry(socket, "Open Existing Blog", message, nil, "error") + :cancel -> + assign(socket, :project_menu_open, false) + + {:error, %{message: message}} -> + append_output_entry(socket, "Open Existing Blog", message, nil, "error") end {:noreply, socket} @@ -1165,7 +1442,8 @@ defmodule BDS.Desktop.ShellLive do {:noreply, set_page_language(socket, language)} end - def handle_event("restore_workbench_session", %{"session" => session_payload}, socket) when is_map(session_payload) do + def handle_event("restore_workbench_session", %{"session" => session_payload}, socket) + when is_map(session_payload) do {:noreply, reload_shell(socket, SessionUtil.restore_workbench_session(session_payload))} end @@ -1202,13 +1480,28 @@ defmodule BDS.Desktop.ShellLive do cond do Map.has_key?(socket.assigns.import_editor_analysis_task_refs, ref) -> - {:noreply, ImportEditor.finish_analysis(socket, ref, result, &reload_shell/2, &append_output_entry/5)} + {:noreply, + ImportEditor.finish_analysis( + socket, + ref, + result, + &reload_shell/2, + &append_output_entry/5 + )} Map.has_key?(socket.assigns.import_editor_execution_task_refs, ref) -> - {:noreply, ImportEditor.finish_execution(socket, ref, result, &reload_shell/2, &append_output_entry/5)} + {:noreply, + ImportEditor.finish_execution( + socket, + ref, + result, + &reload_shell/2, + &append_output_entry/5 + )} true -> - {:noreply, ChatEditor.finish_request(socket, ref, result, &reload_shell/2, &append_output_entry/5)} + {:noreply, + ChatEditor.finish_request(socket, ref, result, &reload_shell/2, &append_output_entry/5)} end end @@ -1216,15 +1509,38 @@ defmodule BDS.Desktop.ShellLive do next_socket = cond do Map.has_key?(socket.assigns.import_editor_analysis_task_refs, ref) -> - ImportEditor.handle_task_down(socket, :analysis, ref, reason, &reload_shell/2, &append_output_entry/5) + ImportEditor.handle_task_down( + socket, + :analysis, + ref, + reason, + &reload_shell/2, + &append_output_entry/5 + ) Map.has_key?(socket.assigns.import_editor_execution_task_refs, ref) -> - ImportEditor.handle_task_down(socket, :execution, ref, reason, &reload_shell/2, &append_output_entry/5) + ImportEditor.handle_task_down( + socket, + :execution, + ref, + reason, + &reload_shell/2, + &append_output_entry/5 + ) true -> case reason do - :normal -> socket - _other -> ChatEditor.finish_request(socket, ref, {:error, :cancelled}, &reload_shell/2, &append_output_entry/5) + :normal -> + socket + + _other -> + ChatEditor.finish_request( + socket, + ref, + {:error, :cancelled}, + &reload_shell/2, + &append_output_entry/5 + ) end end @@ -1232,11 +1548,24 @@ defmodule BDS.Desktop.ShellLive do end def handle_info({:import_analysis_progress, definition_id, step, detail}, socket) do - {:noreply, ImportEditor.note_analysis_progress(socket, definition_id, step, detail, &reload_shell/2)} + {:noreply, + ImportEditor.note_analysis_progress(socket, definition_id, step, detail, &reload_shell/2)} end - def handle_info({:import_execution_progress, definition_id, phase, current, total, detail}, socket) do - {:noreply, ImportEditor.note_execution_progress(socket, definition_id, phase, current, total, detail, &reload_shell/2)} + def handle_info( + {:import_execution_progress, definition_id, phase, current, total, detail}, + socket + ) do + {:noreply, + ImportEditor.note_execution_progress( + socket, + definition_id, + phase, + current, + total, + detail, + &reload_shell/2 + )} end def handle_info({:chat_tool_call, conversation_id, tool_call}, socket) do @@ -1248,7 +1577,8 @@ defmodule BDS.Desktop.ShellLive do end def handle_info({:chat_streaming_content, conversation_id, content}, socket) do - {:noreply, ChatEditor.note_streaming_content(socket, conversation_id, content, &reload_shell/2)} + {:noreply, + ChatEditor.note_streaming_content(socket, conversation_id, content, &reload_shell/2)} end def handle_info({:entity_changed, payload}, socket) when is_map(payload) do @@ -1293,11 +1623,19 @@ defmodule BDS.Desktop.ShellLive do dashboard = ShellData.dashboard(projects.active_project_id) git_badge_count = ShellData.git_badge_count(projects.active_project_id) active_view_id = Atom.to_string(workbench.active_view) - sidebar_data = ShellData.sidebar_view(projects.active_project_id, active_view_id, ShellSidebarState.current_filters(socket, active_view_id)) + + sidebar_data = + ShellData.sidebar_view( + projects.active_project_id, + active_view_id, + ShellSidebarState.current_filters(socket, active_view_id) + ) + sidebar_data = ShellSidebarState.merge_ui_state(socket, active_view_id, sidebar_data) raw_task_status = BDS.Tasks.status_snapshot() activity_buttons = Workbench.activity_buttons(workbench, git_badge_count) page_language = socket.assigns[:page_language] || ShellData.ui_language() + offline_mode = if connected?(socket) do Map.get(socket.assigns, :offline_mode, AI.airplane_mode?(true)) @@ -1315,9 +1653,15 @@ defmodule BDS.Desktop.ShellLive do |> assign(:dashboard_timeline_entries, Map.get(dashboard, :timeline_entries, [])) |> assign(:dashboard_category_counts, Map.get(dashboard, :category_counts, [])) |> assign(:dashboard_recent_posts, Map.get(dashboard, :recent_posts, [])) - |> assign(:dashboard_tag_cloud_items, ShellData.dashboard_tag_cloud_items(Map.get(dashboard, :tag_cloud_items, []))) + |> assign( + :dashboard_tag_cloud_items, + ShellData.dashboard_tag_cloud_items(Map.get(dashboard, :tag_cloud_items, [])) + ) |> assign(:sidebar_data, sidebar_data) - |> assign(:sidebar_header, active_sidebar_label(activity_buttons, workbench.active_view, sidebar_data)) + |> assign( + :sidebar_header, + active_sidebar_label(activity_buttons, workbench.active_view, sidebar_data) + ) |> assign(:assistant_cards, ShellData.assistant_cards()) |> assign(:editor_meta, ShellData.editor_meta(task_status)) |> assign(:task_status, task_status) @@ -1345,7 +1689,8 @@ defmodule BDS.Desktop.ShellLive do |> assign_misc_editor() end - defp translated(text, bindings \\ %{}), do: ShellData.translate(text, bindings, UILocale.current()) + defp translated(text, bindings \\ %{}), + do: ShellData.translate(text, bindings, UILocale.current()) defp encoded_shortcuts(shortcuts), do: Jason.encode!(shortcuts) @@ -1374,7 +1719,7 @@ defmodule BDS.Desktop.ShellLive do |> Enum.map(&(&1.count || 0)) |> Enum.max(fn -> 1 end) - max(4, ((entry.count || 0) / max_count) * 100) + max(4, (entry.count || 0) / max_count * 100) end defp current_tab(%{active_tab: nil}), do: nil @@ -1419,7 +1764,6 @@ defmodule BDS.Desktop.ShellLive do MiscEditor.assign_socket(socket) end - defp create_sidebar_item(socket, kind), do: SidebarCreate.create(socket, kind, sidebar_create_callbacks()) @@ -1436,7 +1780,12 @@ defmodule BDS.Desktop.ShellLive do tab_id = tab_id_for_route(route_atom, Map.fetch!(params, "id")) workbench = - Workbench.open_tab(socket.assigns.workbench, route_atom, tab_id, tab_intent(route_atom, intent)) + Workbench.open_tab( + socket.assigns.workbench, + route_atom, + tab_id, + tab_intent(route_atom, intent) + ) tab_meta = Map.put(socket.assigns.tab_meta, {route_atom, tab_id}, %{ @@ -1453,7 +1802,11 @@ defmodule BDS.Desktop.ShellLive do defp sidebar_create_action(view), do: SidebarCreate.action(view) defp set_page_language(socket, language) do - codes = Enum.map(socket.assigns[:supported_ui_languages] || ShellData.supported_ui_languages(), & &1.code) + codes = + Enum.map( + socket.assigns[:supported_ui_languages] || ShellData.supported_ui_languages(), + & &1.code + ) normalized = language @@ -1474,7 +1827,9 @@ defmodule BDS.Desktop.ShellLive do defp activate_project(socket, project_id, title, message_fun) do cond do - project_id == socket.assigns.projects.active_project_id -> assign(socket, :project_menu_open, false) + project_id == socket.assigns.projects.active_project_id -> + assign(socket, :project_menu_open, false) + true -> case Projects.set_active_project(project_id) do {:ok, project} -> @@ -1499,7 +1854,7 @@ defmodule BDS.Desktop.ShellLive do end defp handle_native_menu_action(socket, action) do - with action_atom when not is_nil(action_atom) <- safe_existing_atom(action) do + with action_atom when not is_nil(action_atom) <- shell_command_atom(action) do if MapSet.member?(@local_menu_actions, action_atom) do reload_shell(socket, MenuBar.execute(socket.assigns.workbench, action_atom)) else @@ -1523,7 +1878,7 @@ defmodule BDS.Desktop.ShellLive do } end - defp safe_existing_atom(action), do: ShellCommandRunner.safe_existing_atom(action) + defp shell_command_atom(action), do: ShellCommandRunner.shell_command_atom(action) defp mac_ui? do case Application.get_env(:bds, :shell_platform) do @@ -1540,5 +1895,4 @@ defmodule BDS.Desktop.ShellLive do |> append_output_entry(title, translated("Command completed"), details) |> assign(:shell_overlay, nil) end - end diff --git a/lib/bds/desktop/shell_live/chat_surface.ex b/lib/bds/desktop/shell_live/chat_surface.ex index 7aa2984..e02a8bf 100644 --- a/lib/bds/desktop/shell_live/chat_surface.ex +++ b/lib/bds/desktop/shell_live/chat_surface.ex @@ -3,6 +3,7 @@ defmodule BDS.Desktop.ShellLive.ChatSurface do import Phoenix.Component, only: [assign: 3] + alias BDS.BoundedAtoms alias BDS.Desktop.ShellData alias BDS.Desktop.ShellLive.{ChatEditor, TabHelpers} alias BDS.UI.Workbench @@ -74,7 +75,12 @@ defmodule BDS.Desktop.ShellLive.ChatSurface do socket |> clear_action_error() |> callbacks.open_sidebar.( - %{"route" => "settings", "id" => "settings-ai", "title" => "Settings", "subtitle" => "AI"}, + %{ + "route" => "settings", + "id" => "settings-ai", + "title" => "Settings", + "subtitle" => "AI" + }, :pin ) @@ -96,7 +102,7 @@ defmodule BDS.Desktop.ShellLive.ChatSurface do ) :switch_view -> - case safe_existing_atom(Map.get(payload, "view")) do + case BoundedAtoms.sidebar_view(Map.get(payload, "view")) do nil -> ChatEditor.set_action_error( socket, @@ -160,7 +166,11 @@ defmodule BDS.Desktop.ShellLive.ChatSurface do end def clear_action_error(%{assigns: %{current_tab: %{type: :chat, id: conversation_id}}} = socket) do - assign(socket, :chat_editor_action_errors, Map.delete(socket.assigns.chat_editor_action_errors, conversation_id)) + assign( + socket, + :chat_editor_action_errors, + Map.delete(socket.assigns.chat_editor_action_errors, conversation_id) + ) end def clear_action_error(socket), do: socket @@ -177,7 +187,8 @@ defmodule BDS.Desktop.ShellLive.ChatSurface do defp decode_payload(_payload), do: %{} - defp maybe_put_form_data(payload, socket, surface_id) when is_binary(surface_id) and surface_id != "" do + defp maybe_put_form_data(payload, socket, surface_id) + when is_binary(surface_id) and surface_id != "" do form_data = ChatEditor.current_surface_data(socket, surface_id) if form_data == %{} do @@ -209,17 +220,13 @@ defmodule BDS.Desktop.ShellLive.ChatSurface do end end - defp safe_existing_atom(action) when is_binary(action) do - String.to_existing_atom(action) - rescue - ArgumentError -> nil - end - - defp safe_existing_atom(_), do: nil - defp assistant_reply(socket) do if socket.assigns.offline_mode do - ShellData.translate("Automatic AI actions stay gated by airplane mode.", %{}, socket.assigns.page_language) + ShellData.translate( + "Automatic AI actions stay gated by airplane mode.", + %{}, + socket.assigns.page_language + ) else ShellData.translate( "The assistant sidebar chat surface is ready, but model execution is not connected yet.", diff --git a/lib/bds/desktop/shell_live/code_entity_editor.ex b/lib/bds/desktop/shell_live/code_entity_editor.ex index ba540b0..dc93d83 100644 --- a/lib/bds/desktop/shell_live/code_entity_editor.ex +++ b/lib/bds/desktop/shell_live/code_entity_editor.ex @@ -8,7 +8,7 @@ defmodule BDS.Desktop.ShellLive.CodeEntityEditor do alias BDS.Scripts.Script alias BDS.Templates.Template - embed_templates "code_entity_editor_html/*" + embed_templates("code_entity_editor_html/*") def assign_socket(socket) do socket @@ -20,7 +20,10 @@ defmodule BDS.Desktop.ShellLive.CodeEntityEditor do %{id: script_id} = socket.assigns.current_tab socket - |> assign(:script_editor_drafts, Map.put(socket.assigns.script_editor_drafts, script_id, normalize_script_params(params))) + |> assign( + :script_editor_drafts, + Map.put(socket.assigns.script_editor_drafts, script_id, normalize_script_params(params)) + ) |> reload.(socket.assigns.workbench) end @@ -28,7 +31,9 @@ defmodule BDS.Desktop.ShellLive.CodeEntityEditor do %{id: script_id} = socket.assigns.current_tab case Scripts.get_script(script_id) do - nil -> reload.(socket, socket.assigns.workbench) + nil -> + reload.(socket, socket.assigns.workbench) + %Script{} = script -> draft = current_script_draft(socket.assigns, script) @@ -37,7 +42,10 @@ defmodule BDS.Desktop.ShellLive.CodeEntityEditor do case Scripts.update_script(script.id, script_attrs(draft)) do {:ok, _updated} -> socket - |> assign(:script_editor_drafts, Map.delete(socket.assigns.script_editor_drafts, script.id)) + |> assign( + :script_editor_drafts, + Map.delete(socket.assigns.script_editor_drafts, script.id) + ) |> reload.(socket.assigns.workbench) {:error, reason} -> @@ -58,11 +66,18 @@ defmodule BDS.Desktop.ShellLive.CodeEntityEditor do %{id: script_id} = socket.assigns.current_tab case Scripts.get_script(script_id) do - nil -> reload.(socket, socket.assigns.workbench) + nil -> + reload.(socket, socket.assigns.workbench) + %Script{} = script -> case Scripting.validate(current_script_draft(socket.assigns, script)["content"] || "") do - :ok -> append_output.(socket, translated("Scripts"), translated("Syntax is valid")) |> reload.(socket.assigns.workbench) - {:error, reason} -> append_output.(socket, translated("Scripts"), inspect(reason), nil, "error") |> reload.(socket.assigns.workbench) + :ok -> + append_output.(socket, translated("Scripts"), translated("Syntax is valid")) + |> reload.(socket.assigns.workbench) + + {:error, reason} -> + append_output.(socket, translated("Scripts"), inspect(reason), nil, "error") + |> reload.(socket.assigns.workbench) end end end @@ -71,11 +86,18 @@ defmodule BDS.Desktop.ShellLive.CodeEntityEditor do %{id: script_id} = socket.assigns.current_tab case Scripts.get_script(script_id) do - nil -> reload.(socket, socket.assigns.workbench) + nil -> + reload.(socket, socket.assigns.workbench) + %Script{} = script -> draft = current_script_draft(socket.assigns, script) - case Scripting.execute_project_script(script.project_id, draft["content"] || "", draft["entrypoint"] || "main", []) do + case Scripting.execute_project_script( + script.project_id, + draft["content"] || "", + draft["entrypoint"] || "main", + [] + ) do {:ok, result} -> socket |> append_output.(translated("Scripts"), inspect(result)) @@ -93,8 +115,12 @@ defmodule BDS.Desktop.ShellLive.CodeEntityEditor do %{id: script_id} = socket.assigns.current_tab case Scripts.delete_script(script_id) do - {:ok, _deleted} -> reload.(socket, BDS.UI.Workbench.close_tab(socket.assigns.workbench, :scripts, script_id)) - {:error, reason} -> append_output.(socket, translated("Scripts"), inspect(reason), nil, "error") |> reload.(socket.assigns.workbench) + {:ok, _deleted} -> + reload.(socket, BDS.UI.Workbench.close_tab(socket.assigns.workbench, :scripts, script_id)) + + {:error, reason} -> + append_output.(socket, translated("Scripts"), inspect(reason), nil, "error") + |> reload.(socket.assigns.workbench) end end @@ -102,7 +128,14 @@ defmodule BDS.Desktop.ShellLive.CodeEntityEditor do %{id: template_id} = socket.assigns.current_tab socket - |> assign(:template_editor_drafts, Map.put(socket.assigns.template_editor_drafts, template_id, normalize_template_params(params))) + |> assign( + :template_editor_drafts, + Map.put( + socket.assigns.template_editor_drafts, + template_id, + normalize_template_params(params) + ) + ) |> reload.(socket.assigns.workbench) end @@ -110,18 +143,28 @@ defmodule BDS.Desktop.ShellLive.CodeEntityEditor do %{id: template_id} = socket.assigns.current_tab case Templates.get_template(template_id) do - nil -> reload.(socket, socket.assigns.workbench) + nil -> + reload.(socket, socket.assigns.workbench) + %Template{} = template -> draft = current_template_draft(socket.assigns, template) with {:ok, %{valid: true}} <- MCP.validate_template(draft["content"] || ""), {:ok, _updated} <- Templates.update_template(template.id, template_attrs(draft)) do socket - |> assign(:template_editor_drafts, Map.delete(socket.assigns.template_editor_drafts, template.id)) + |> assign( + :template_editor_drafts, + Map.delete(socket.assigns.template_editor_drafts, template.id) + ) |> reload.(socket.assigns.workbench) else - {:ok, %{valid: false, errors: errors}} -> append_output.(socket, translated("Templates"), Enum.join(errors, "; "), nil, "error") |> reload.(socket.assigns.workbench) - {:error, reason} -> append_output.(socket, translated("Templates"), inspect(reason), nil, "error") |> reload.(socket.assigns.workbench) + {:ok, %{valid: false, errors: errors}} -> + append_output.(socket, translated("Templates"), Enum.join(errors, "; "), nil, "error") + |> reload.(socket.assigns.workbench) + + {:error, reason} -> + append_output.(socket, translated("Templates"), inspect(reason), nil, "error") + |> reload.(socket.assigns.workbench) end end end @@ -130,11 +173,24 @@ defmodule BDS.Desktop.ShellLive.CodeEntityEditor do %{id: template_id} = socket.assigns.current_tab case Templates.get_template(template_id) do - nil -> reload.(socket, socket.assigns.workbench) + nil -> + reload.(socket, socket.assigns.workbench) + %Template{} = template -> - case MCP.validate_template(current_template_draft(socket.assigns, template)["content"] || "") do - {:ok, %{valid: true}} -> append_output.(socket, translated("Templates"), translated("Template syntax is valid")) |> reload.(socket.assigns.workbench) - {:ok, %{valid: false, errors: errors}} -> append_output.(socket, translated("Templates"), Enum.join(errors, "; "), nil, "error") |> reload.(socket.assigns.workbench) + case MCP.validate_template( + current_template_draft(socket.assigns, template)["content"] || "" + ) do + {:ok, %{valid: true}} -> + append_output.( + socket, + translated("Templates"), + translated("Template syntax is valid") + ) + |> reload.(socket.assigns.workbench) + + {:ok, %{valid: false, errors: errors}} -> + append_output.(socket, translated("Templates"), Enum.join(errors, "; "), nil, "error") + |> reload.(socket.assigns.workbench) end end end @@ -143,16 +199,26 @@ defmodule BDS.Desktop.ShellLive.CodeEntityEditor do %{id: template_id} = socket.assigns.current_tab case Templates.delete_template(template_id, force: true) do - {:ok, _deleted} -> reload.(socket, BDS.UI.Workbench.close_tab(socket.assigns.workbench, :templates, template_id)) - {:error, reason} -> append_output.(socket, translated("Templates"), inspect(reason), nil, "error") |> reload.(socket.assigns.workbench) + {:ok, _deleted} -> + reload.( + socket, + BDS.UI.Workbench.close_tab(socket.assigns.workbench, :templates, template_id) + ) + + {:error, reason} -> + append_output.(socket, translated("Templates"), inspect(reason), nil, "error") + |> reload.(socket.assigns.workbench) end end def build_script(%{current_tab: %{type: :scripts, id: script_id}} = assigns) do case Scripts.get_script(script_id) do - nil -> nil + nil -> + nil + %Script{} = script -> draft = current_script_draft(assigns, script) + %{ id: script.id, title: draft["title"], @@ -172,9 +238,12 @@ defmodule BDS.Desktop.ShellLive.CodeEntityEditor do def build_template(%{current_tab: %{type: :templates, id: template_id}} = assigns) do case Templates.get_template(template_id) do - nil -> nil + nil -> + nil + %Template{} = template -> draft = current_template_draft(assigns, template) + %{ id: template.id, title: draft["title"], @@ -190,7 +259,8 @@ defmodule BDS.Desktop.ShellLive.CodeEntityEditor do def build_template(_assigns), do: nil - def translated(text, bindings \\ %{}), do: ShellData.translate(text, bindings, BDS.Desktop.UILocale.current()) + def translated(text, bindings \\ %{}), + do: ShellData.translate(text, bindings, BDS.Desktop.UILocale.current()) def format_timestamp(nil), do: "" def format_timestamp(timestamp), do: BDS.Persistence.timestamp_to_iso8601(timestamp) @@ -241,17 +311,21 @@ defmodule BDS.Desktop.ShellLive.CodeEntityEditor do %{ title: draft["title"], slug: draft["slug"], - kind: String.to_existing_atom(draft["kind"]), + kind: BDS.BoundedAtoms.script_kind(draft["kind"], :utility), entrypoint: draft["entrypoint"], enabled: draft["enabled"], content: draft["content"] } - rescue - _error -> %{title: draft["title"], slug: draft["slug"], kind: :utility, entrypoint: draft["entrypoint"], enabled: draft["enabled"], content: draft["content"]} end defp template_attrs(draft) do - %{title: draft["title"], slug: draft["slug"], kind: normalize_template_kind(draft["kind"]), enabled: draft["enabled"], content: draft["content"]} + %{ + title: draft["title"], + slug: draft["slug"], + kind: normalize_template_kind(draft["kind"]), + enabled: draft["enabled"], + content: draft["content"] + } end defp normalize_template_kind("post"), do: :post @@ -261,8 +335,13 @@ defmodule BDS.Desktop.ShellLive.CodeEntityEditor do defp normalize_template_kind(_kind), do: :post defp discover_entrypoints(content) do - ["main" | Regex.scan(~r/function\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/, content || "", capture: :all_but_first) - |> List.flatten() - |> Enum.reject(&(&1 == "main"))] + [ + "main" + | Regex.scan(~r/function\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/, content || "", + capture: :all_but_first + ) + |> List.flatten() + |> Enum.reject(&(&1 == "main")) + ] end end diff --git a/lib/bds/desktop/shell_live/import_editor.ex b/lib/bds/desktop/shell_live/import_editor.ex index e79ca65..097c040 100644 --- a/lib/bds/desktop/shell_live/import_editor.ex +++ b/lib/bds/desktop/shell_live/import_editor.ex @@ -5,6 +5,7 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do alias BDS.AI alias BDS.Desktop.ShellData + alias BDS.Desktop.ShellLive.ImportEditor.{ AnalysisState, ConflictResolution, @@ -40,13 +41,28 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do defdelegate change_definition(socket, params, reload), to: AnalysisState defdelegate select_uploads_folder(socket, reload, append_output), to: AnalysisState defdelegate select_and_analyze(socket, reload, append_output), to: AnalysisState - defdelegate note_analysis_progress(socket, definition_id, step, detail, reload), to: AnalysisState + + defdelegate note_analysis_progress(socket, definition_id, step, detail, reload), + to: AnalysisState + defdelegate finish_analysis(socket, ref, result, reload, append_output), to: AnalysisState defdelegate execute_import(socket, reload, append_output), to: ProgressTracking - defdelegate note_execution_progress(socket, definition_id, phase, current, total, detail, reload), to: ProgressTracking + + defdelegate note_execution_progress( + socket, + definition_id, + phase, + current, + total, + detail, + reload + ), to: ProgressTracking + defdelegate finish_execution(socket, ref, result, reload, append_output), to: ProgressTracking - defdelegate handle_task_down(socket, kind, ref, reason, reload, append_output), to: ProgressTracking + + defdelegate handle_task_down(socket, kind, ref, reason, reload, append_output), + to: ProgressTracking defdelegate change_conflict_resolution(socket, params, reload), to: ConflictResolution @@ -66,9 +82,24 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do definition -> report = ImportDefinitions.decode_analysis_result(definition) taxonomy_terms = existing_taxonomy_terms(socket.assigns.projects.active_project_id) - analysis_state = Map.get(socket.assigns.import_editor_analysis_states, definition.id, default_analysis_state()) - execution_state = Map.get(socket.assigns.import_editor_execution_states, definition.id, default_execution_state()) - sections = Map.get(socket.assigns.import_editor_sections, definition.id, default_sections()) + + analysis_state = + Map.get( + socket.assigns.import_editor_analysis_states, + definition.id, + default_analysis_state() + ) + + execution_state = + Map.get( + socket.assigns.import_editor_execution_states, + definition.id, + default_execution_state() + ) + + sections = + Map.get(socket.assigns.import_editor_sections, definition.id, default_sections()) + selected_model = selected_model(socket.assigns, definition.id) available_models = AI.available_chat_models(selected_model) @@ -86,7 +117,8 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do sections: sections, selected_model: selected_model, selected_model_label: selected_model_label(selected_model, available_models), - model_selector_open?: Map.get(socket.assigns.import_editor_model_selectors_open, definition.id, false), + model_selector_open?: + Map.get(socket.assigns.import_editor_model_selectors_open, definition.id, false), available_models: available_models, offline?: Map.get(socket.assigns, :offline_mode, true), is_loading: analysis_state.loading @@ -110,14 +142,29 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do def toggle_section(socket, section, reload) do with %{id: definition_id} <- socket.assigns.current_tab, - section_key when section_key in ["post_conflicts", "page_conflicts", "posts", "other", "pages", "media", "taxonomy", "macros"] <- section do + section_key + when section_key in [ + "post_conflicts", + "page_conflicts", + "posts", + "other", + "pages", + "media", + "taxonomy", + "macros" + ] <- section, + section_atom when not is_nil(section_atom) <- + BDS.BoundedAtoms.import_section(section_key) do next_sections = socket.assigns.import_editor_sections |> Map.get(definition_id, default_sections()) - |> Map.update!(String.to_existing_atom(section_key), &(!&1)) + |> Map.update!(section_atom, &(!&1)) socket - |> assign(:import_editor_sections, Map.put(socket.assigns.import_editor_sections, definition_id, next_sections)) + |> assign( + :import_editor_sections, + Map.put(socket.assigns.import_editor_sections, definition_id, next_sections) + ) |> reload.(socket.assigns.workbench) else _other -> reload.(socket, socket.assigns.workbench) @@ -129,7 +176,10 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do current = Map.get(socket.assigns.import_editor_model_selectors_open, definition_id, false) socket - |> assign(:import_editor_model_selectors_open, Map.put(socket.assigns.import_editor_model_selectors_open, definition_id, not current)) + |> assign( + :import_editor_model_selectors_open, + Map.put(socket.assigns.import_editor_model_selectors_open, definition_id, not current) + ) |> reload.(socket.assigns.workbench) else _other -> reload.(socket, socket.assigns.workbench) @@ -139,31 +189,73 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do def select_ai_model(socket, model_id, reload) do with %{id: definition_id} <- socket.assigns.current_tab do socket - |> assign(:import_editor_selected_models, Map.put(socket.assigns.import_editor_selected_models, definition_id, model_id)) - |> assign(:import_editor_model_selectors_open, Map.put(socket.assigns.import_editor_model_selectors_open, definition_id, false)) + |> assign( + :import_editor_selected_models, + Map.put(socket.assigns.import_editor_selected_models, definition_id, model_id) + ) + |> assign( + :import_editor_model_selectors_open, + Map.put(socket.assigns.import_editor_model_selectors_open, definition_id, false) + ) |> reload.(socket.assigns.workbench) else _other -> reload.(socket, socket.assigns.workbench) end end - attr :import_editor, :map, required: true + attr(:import_editor, :map, required: true) def import_editor(assigns) do assigns = assigns |> assign(:report, Map.get(assigns.import_editor, :report)) - |> assign(:analysis_state, Map.get(assigns.import_editor, :analysis_state, default_analysis_state())) + |> assign( + :analysis_state, + Map.get(assigns.import_editor, :analysis_state, default_analysis_state()) + ) |> assign(:execution_state, Map.get(assigns.import_editor, :execution_state)) - |> assign(:counts, Map.get(assigns.import_editor, :importable_counts, %{total: 0, tags: 0, posts: 0, media: 0, pages: 0})) + |> assign( + :counts, + Map.get(assigns.import_editor, :importable_counts, %{ + total: 0, + tags: 0, + posts: 0, + media: 0, + pages: 0 + }) + ) |> assign(:sections, Map.get(assigns.import_editor, :sections, default_sections())) |> assign(:detail_posts, detail_items(Map.get(assigns.import_editor, :report), :posts)) |> assign(:detail_pages, detail_items(Map.get(assigns.import_editor, :report), :pages)) |> assign(:detail_media, detail_items(Map.get(assigns.import_editor, :report), :media)) - |> assign(:post_conflicts, Enum.filter(detail_items(Map.get(assigns.import_editor, :report), :posts), &(&1.status == "conflict"))) - |> assign(:page_conflicts, Enum.filter(detail_items(Map.get(assigns.import_editor, :report), :pages), &(&1.status == "conflict"))) - |> assign(:post_items, Enum.filter(detail_items(Map.get(assigns.import_editor, :report), :posts), &(Map.get(&1, :post_type, "post") == "post"))) - |> assign(:other_items, Enum.reject(detail_items(Map.get(assigns.import_editor, :report), :posts), &(Map.get(&1, :post_type, "post") == "post"))) + |> assign( + :post_conflicts, + Enum.filter( + detail_items(Map.get(assigns.import_editor, :report), :posts), + &(&1.status == "conflict") + ) + ) + |> assign( + :page_conflicts, + Enum.filter( + detail_items(Map.get(assigns.import_editor, :report), :pages), + &(&1.status == "conflict") + ) + ) + |> assign( + :post_items, + Enum.filter( + detail_items(Map.get(assigns.import_editor, :report), :posts), + &(Map.get(&1, :post_type, "post") == "post") + ) + ) + |> assign( + :other_items, + Enum.reject( + detail_items(Map.get(assigns.import_editor, :report), :posts), + &(Map.get(&1, :post_type, "post") == "post") + ) + ) ~H"""
@@ -450,10 +542,10 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do """ end - attr :title, :string, required: true - attr :items, :list, required: true - attr :expanded, :boolean, required: true - attr :section, :string, required: true + attr(:title, :string, required: true) + attr(:items, :list, required: true) + attr(:expanded, :boolean, required: true) + attr(:section, :string, required: true) def conflict_section(assigns) do ~H""" @@ -499,11 +591,11 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do """ end - attr :title, :string, required: true - attr :items, :list, required: true - attr :expanded, :boolean, required: true - attr :section, :string, required: true - attr :show_type, :boolean, default: false + attr(:title, :string, required: true) + attr(:items, :list, required: true) + attr(:expanded, :boolean, required: true) + attr(:section, :string, required: true) + attr(:show_type, :boolean, default: false) def post_detail_section(assigns) do ~H""" @@ -549,10 +641,10 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do """ end - attr :title, :string, required: true - attr :items, :list, required: true - attr :expanded, :boolean, required: true - attr :section, :string, required: true + attr(:title, :string, required: true) + attr(:items, :list, required: true) + attr(:expanded, :boolean, required: true) + attr(:section, :string, required: true) def media_detail_section(assigns) do ~H""" @@ -590,8 +682,8 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do """ end - attr :label, :string, required: true - attr :stats, :map, required: true + attr(:label, :string, required: true) + attr(:stats, :map, required: true) def stat_card(assigns) do ~H""" @@ -608,8 +700,8 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do """ end - attr :label, :string, required: true - attr :stats, :map, required: true + attr(:label, :string, required: true) + attr(:stats, :map, required: true) def other_stat_card(assigns) do ~H""" @@ -625,8 +717,8 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do """ end - attr :label, :string, required: true - attr :stats, :map, required: true + attr(:label, :string, required: true) + attr(:stats, :map, required: true) def media_stat_card(assigns) do ~H""" @@ -644,8 +736,8 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do """ end - attr :label, :string, required: true - attr :stats, :map, required: true + attr(:label, :string, required: true) + attr(:stats, :map, required: true) def taxonomy_stat_card(assigns) do ~H""" @@ -661,11 +753,11 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do """ end - attr :title, :string, required: true - attr :items, :list, required: true - attr :suggestions, :list, required: true - attr :edit, :map, default: nil - attr :type, :string, required: true + attr(:title, :string, required: true) + attr(:items, :list, required: true) + attr(:suggestions, :list, required: true) + attr(:edit, :map, default: nil) + attr(:type, :string, required: true) def taxonomy_group(assigns) do ~H""" @@ -744,7 +836,9 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do max(8, value / max(max_value, 1) * 100) end - defp total_stats(stats), do: stats.new_count + stats.update_count + stats.conflict_count + stats.duplicate_count + defp total_stats(stats), + do: stats.new_count + stats.update_count + stats.conflict_count + stats.duplicate_count + defp total_media_stats(stats), do: total_stats(stats) + stats.missing_count defp selected_model(assigns, definition_id) do @@ -770,7 +864,9 @@ defmodule BDS.Desktop.ShellLive.ImportEditor do end end - defp translated(text, bindings \\ %{}), do: ShellData.translate(text, bindings, BDS.Desktop.UILocale.current()) + defp translated(text, bindings \\ %{}), + do: ShellData.translate(text, bindings, BDS.Desktop.UILocale.current()) + defp present?(value), do: value not in [nil, ""] defp blank?(value), do: value in [nil, ""] end diff --git a/lib/bds/desktop/shell_live/import_editor/taxonomy_editing.ex b/lib/bds/desktop/shell_live/import_editor/taxonomy_editing.ex index aefad7d..3a16b62 100644 --- a/lib/bds/desktop/shell_live/import_editor/taxonomy_editing.ex +++ b/lib/bds/desktop/shell_live/import_editor/taxonomy_editing.ex @@ -4,7 +4,11 @@ defmodule BDS.Desktop.ShellLive.ImportEditor.TaxonomyEditing do alias BDS.{AI, ImportDefinitions, Metadata, Tags} alias BDS.Desktop.ShellData - def start_taxonomy_edit(socket, %{"type" => type, "name" => name, "mapped_to" => mapped_to}, reload) do + def start_taxonomy_edit( + socket, + %{"type" => type, "name" => name, "mapped_to" => mapped_to}, + reload + ) do with %{id: definition_id} <- socket.assigns.current_tab do socket |> Phoenix.Component.assign( @@ -24,22 +28,40 @@ defmodule BDS.Desktop.ShellLive.ImportEditor.TaxonomyEditing do def cancel_taxonomy_edit(socket, reload) do with %{id: definition_id} <- socket.assigns.current_tab do socket - |> Phoenix.Component.assign(:import_editor_taxonomy_edits, Map.delete(socket.assigns.import_editor_taxonomy_edits, definition_id)) + |> Phoenix.Component.assign( + :import_editor_taxonomy_edits, + Map.delete(socket.assigns.import_editor_taxonomy_edits, definition_id) + ) |> reload.(socket.assigns.workbench) else _other -> reload.(socket, socket.assigns.workbench) end end - def save_taxonomy_edit(socket, %{"type" => type, "name" => name, "mapped_to" => mapped_to}, reload) do + def save_taxonomy_edit( + socket, + %{"type" => type, "name" => name, "mapped_to" => mapped_to}, + reload + ) do with %{id: definition_id} <- socket.assigns.current_tab, %{} = definition <- ImportDefinitions.get_definition(definition_id), %{} = report <- ImportDefinitions.decode_analysis_result(definition), - normalized_value <- normalize_taxonomy_mapping_value(socket.assigns.projects.active_project_id, type, mapped_to), + normalized_value <- + normalize_taxonomy_mapping_value( + socket.assigns.projects.active_project_id, + type, + mapped_to + ), updated_report <- update_taxonomy_mapping(report, type, name, normalized_value), - {:ok, _definition} <- ImportDefinitions.update_definition(definition_id, %{last_analysis_result: updated_report}) do + {:ok, _definition} <- + ImportDefinitions.update_definition(definition_id, %{ + last_analysis_result: updated_report + }) do socket - |> Phoenix.Component.assign(:import_editor_taxonomy_edits, Map.delete(socket.assigns.import_editor_taxonomy_edits, definition_id)) + |> Phoenix.Component.assign( + :import_editor_taxonomy_edits, + Map.delete(socket.assigns.import_editor_taxonomy_edits, definition_id) + ) |> reload.(socket.assigns.workbench) else _other -> reload.(socket, socket.assigns.workbench) @@ -57,7 +79,16 @@ defmodule BDS.Desktop.ShellLive.ImportEditor.TaxonomyEditing do cond do socket.assigns.offline_mode -> socket - |> append_output.(translated("activity.import"), ShellData.translate("Automatic AI actions stay gated by airplane mode.", %{}, socket.assigns.page_language), nil, "info") + |> append_output.( + translated("activity.import"), + ShellData.translate( + "Automatic AI actions stay gated by airplane mode.", + %{}, + socket.assigns.page_language + ), + nil, + "info" + ) |> reload.(socket.assigns.workbench) true -> @@ -68,21 +99,41 @@ defmodule BDS.Desktop.ShellLive.ImportEditor.TaxonomyEditing do tags: Enum.map(Map.get(report.items, :tags, []), & &1.name) } - opts = maybe_put_option([], :model, Map.get(socket.assigns.import_editor_selected_models, definition_id)) + opts = + maybe_put_option( + [], + :model, + Map.get(socket.assigns.import_editor_selected_models, definition_id) + ) case AI.analyze_import_taxonomy(import_terms, taxonomy_terms, opts) do {:ok, analysis} -> updated_report = apply_taxonomy_mappings(report, analysis) - {:ok, _definition} = ImportDefinitions.update_definition(definition_id, %{last_analysis_result: updated_report}) + + {:ok, _definition} = + ImportDefinitions.update_definition(definition_id, %{ + last_analysis_result: updated_report + }) + mapped_count = auto_mapped_count(report, updated_report) socket - |> append_output.(translated("activity.import"), translated("importAnalysis.mappedCount", %{count: mapped_count}), Map.get(socket.assigns.import_editor_selected_models, definition_id), "info") + |> append_output.( + translated("activity.import"), + translated("importAnalysis.mappedCount", %{count: mapped_count}), + Map.get(socket.assigns.import_editor_selected_models, definition_id), + "info" + ) |> reload.(socket.assigns.workbench) {:error, reason} -> socket - |> append_output.(translated("activity.import"), inspect(reason), Map.get(socket.assigns.import_editor_selected_models, definition_id), "error") + |> append_output.( + translated("activity.import"), + inspect(reason), + Map.get(socket.assigns.import_editor_selected_models, definition_id), + "error" + ) |> reload.(socket.assigns.workbench) end end @@ -106,7 +157,11 @@ defmodule BDS.Desktop.ShellLive.ImportEditor.TaxonomyEditing do end) end) - Map.put(updated_report, stat_key(bucket_key), rebuild_taxonomy_stats(get_in(updated_report, [:items, bucket_key]) || [])) + Map.put( + updated_report, + stat_key(bucket_key), + rebuild_taxonomy_stats(get_in(updated_report, [:items, bucket_key]) || []) + ) end def rebuild_taxonomy_stats(items) do @@ -122,12 +177,24 @@ defmodule BDS.Desktop.ShellLive.ImportEditor.TaxonomyEditing do def apply_taxonomy_mappings(report, analysis) do report - |> update_in([:items, :categories], &apply_taxonomy_mapping_bucket(&1, Map.get(analysis, :category_mappings, %{}))) - |> update_in([:items, :tags], &apply_taxonomy_mapping_bucket(&1, Map.get(analysis, :tag_mappings, %{}))) + |> update_in( + [:items, :categories], + &apply_taxonomy_mapping_bucket(&1, Map.get(analysis, :category_mappings, %{})) + ) + |> update_in( + [:items, :tags], + &apply_taxonomy_mapping_bucket(&1, Map.get(analysis, :tag_mappings, %{})) + ) |> then(fn updated_report -> updated_report - |> Map.put(:category_stats, rebuild_taxonomy_stats(get_in(updated_report, [:items, :categories]) || [])) - |> Map.put(:tag_stats, rebuild_taxonomy_stats(get_in(updated_report, [:items, :tags]) || [])) + |> Map.put( + :category_stats, + rebuild_taxonomy_stats(get_in(updated_report, [:items, :categories]) || []) + ) + |> Map.put( + :tag_stats, + rebuild_taxonomy_stats(get_in(updated_report, [:items, :tags]) || []) + ) end) end @@ -159,14 +226,15 @@ defmodule BDS.Desktop.ShellLive.ImportEditor.TaxonomyEditing do value -> project_id |> existing_taxonomy_terms() - |> Map.get(String.to_existing_atom(type), []) + |> Map.get(BDS.BoundedAtoms.taxonomy_type(type), []) |> Enum.find(fn term -> String.downcase(term) == String.downcase(value) end) end end def auto_mapped_count(previous_report, next_report) do previous_count = - (Map.get(previous_report.items, :categories, []) ++ Map.get(previous_report.items, :tags, [])) + (Map.get(previous_report.items, :categories, []) ++ + Map.get(previous_report.items, :tags, [])) |> Enum.count(&present?(&1.mapped_to)) next_count = @@ -199,7 +267,9 @@ defmodule BDS.Desktop.ShellLive.ImportEditor.TaxonomyEditing do def maybe_put_option(opts, _key, nil), do: opts def maybe_put_option(opts, key, value), do: Keyword.put(opts, key, value) - defp translated(text, bindings \\ %{}), do: ShellData.translate(text, bindings, BDS.Desktop.UILocale.current()) + defp translated(text, bindings \\ %{}), + do: ShellData.translate(text, bindings, BDS.Desktop.UILocale.current()) + defp present?(value), do: value not in [nil, ""] defp blank_to_nil(""), do: nil defp blank_to_nil(value), do: value diff --git a/lib/bds/desktop/shell_live/settings_editor/mcp_config.ex b/lib/bds/desktop/shell_live/settings_editor/mcp_config.ex index db33e45..29fb5d5 100644 --- a/lib/bds/desktop/shell_live/settings_editor/mcp_config.ex +++ b/lib/bds/desktop/shell_live/settings_editor/mcp_config.ex @@ -62,26 +62,30 @@ defmodule BDS.Desktop.ShellLive.SettingsEditor.MCPConfig do end defp find_mcp_agent(agent) do - normalized = - agent - |> to_string() - |> String.to_existing_atom() + normalized = BDS.BoundedAtoms.mcp_agent(agent) Enum.find(@mcp_agents, &(&1.id == normalized)) - rescue - _error -> nil end defp format_config_error({:read_config, path, reason}) do - translated("Could not read MCP config %{path}: %{reason}", path: path, reason: inspect(reason)) + translated("Could not read MCP config %{path}: %{reason}", + path: path, + reason: inspect(reason) + ) end defp format_config_error({:write_config, path, reason}) do - translated("Could not write MCP config %{path}: %{reason}", path: path, reason: inspect(reason)) + translated("Could not write MCP config %{path}: %{reason}", + path: path, + reason: inspect(reason) + ) end defp format_config_error({:create_config_dir, path, reason}) do - translated("Could not create MCP config folder %{path}: %{reason}", path: path, reason: inspect(reason)) + translated("Could not create MCP config folder %{path}: %{reason}", + path: path, + reason: inspect(reason) + ) end defp format_config_error({:decode_config, path, _reason}) do @@ -103,7 +107,9 @@ defmodule BDS.Desktop.ShellLive.SettingsEditor.MCPConfig do end defp mcp_config_path(%{supported?: false}), do: nil - defp mcp_config_path(%{id: agent_id}), do: AgentConfig.config_path(agent_id, System.user_home!()) + + defp mcp_config_path(%{id: agent_id}), + do: AgentConfig.config_path(agent_id, System.user_home!()) defp mcp_server_present?(config, :github_copilot) do config diff --git a/lib/bds/desktop/shell_live/shell_command_runner.ex b/lib/bds/desktop/shell_live/shell_command_runner.ex index 6cb7556..0704541 100644 --- a/lib/bds/desktop/shell_live/shell_command_runner.ex +++ b/lib/bds/desktop/shell_live/shell_command_runner.ex @@ -3,6 +3,7 @@ defmodule BDS.Desktop.ShellLive.ShellCommandRunner do import Phoenix.Component, only: [assign: 3] + alias BDS.BoundedAtoms alias BDS.Desktop.ShellCommands alias BDS.Desktop.ShellLive.{TabHelpers, TaskLocalization} alias BDS.UI.Workbench @@ -20,18 +21,34 @@ defmodule BDS.Desktop.ShellLive.ShellCommandRunner do apply_result(socket, result, callbacks) {:error, %{message: message}} -> - callbacks.append_output.(socket, TaskLocalization.command_title(action), message, nil, "error") + callbacks.append_output.( + socket, + TaskLocalization.command_title(action), + message, + nil, + "error" + ) {:error, reason} -> - callbacks.append_output.(socket, TaskLocalization.command_title(action), inspect(reason), nil, "error") + callbacks.append_output.( + socket, + TaskLocalization.command_title(action), + inspect(reason), + nil, + "error" + ) end end - def apply_result(socket, %{kind: "task_queued", title: title, message: message, panel_tab: panel_tab}, callbacks) do + def apply_result( + socket, + %{kind: "task_queued", title: title, message: message, panel_tab: panel_tab}, + callbacks + ) do workbench = socket.assigns.workbench |> Workbench.set_panel_visible(true) - |> Workbench.set_panel_tab(String.to_existing_atom(panel_tab)) + |> Workbench.set_panel_tab(BoundedAtoms.panel_tab(panel_tab, :tasks)) socket |> callbacks.append_output.( @@ -53,7 +70,11 @@ defmodule BDS.Desktop.ShellLive.ShellCommandRunner do ) end - def apply_result(socket, %{kind: "open_url", title: title, message: message, url: url}, callbacks) do + def apply_result( + socket, + %{kind: "open_url", title: title, message: message, url: url}, + callbacks + ) do callbacks.append_output.( socket, TaskLocalization.translate_for_socket(socket, title), @@ -63,8 +84,12 @@ defmodule BDS.Desktop.ShellLive.ShellCommandRunner do ) end - def apply_result(socket, %{kind: "open_editor", route: route, title: title, subtitle: subtitle} = result, callbacks) do - route_atom = String.to_existing_atom(route) + def apply_result( + socket, + %{kind: "open_editor", route: route, title: title, subtitle: subtitle} = result, + callbacks + ) do + route_atom = BoundedAtoms.editor_route(route, :dashboard) tab_id = TabHelpers.tab_id_for_route(route_atom, route) workbench = Workbench.open_tab(socket.assigns.workbench, route_atom, tab_id, :pin) @@ -75,7 +100,11 @@ defmodule BDS.Desktop.ShellLive.ShellCommandRunner do action: Map.get(result, :action), payload: Map.get(result, :payload), project_id: Map.get(result, :project_id), - editor_meta: TaskLocalization.translate_editor_meta(Map.get(result, :editorMeta, []), socket.assigns.page_language) + editor_meta: + TaskLocalization.translate_editor_meta( + Map.get(result, :editorMeta, []), + socket.assigns.page_language + ) }) socket @@ -85,11 +114,5 @@ defmodule BDS.Desktop.ShellLive.ShellCommandRunner do def apply_result(socket, _result, _callbacks), do: socket - def safe_existing_atom(action) when is_binary(action) do - String.to_existing_atom(action) - rescue - ArgumentError -> nil - end - - def safe_existing_atom(_), do: nil + def shell_command_atom(action), do: BoundedAtoms.shell_command(action) end diff --git a/lib/bds/desktop/shell_live/sidebar_components.ex b/lib/bds/desktop/shell_live/sidebar_components.ex index a2f697d..5ac02f5 100644 --- a/lib/bds/desktop/shell_live/sidebar_components.ex +++ b/lib/bds/desktop/shell_live/sidebar_components.ex @@ -463,7 +463,8 @@ defmodule BDS.Desktop.ShellLive.SidebarComponents do """ end - defp translated(text, bindings \\ %{}), do: ShellData.translate(text, bindings, BDS.Desktop.UILocale.current()) + defp translated(text, bindings \\ %{}), + do: ShellData.translate(text, bindings, BDS.Desktop.UILocale.current()) defp template_sidebar?(sidebar_data), do: Map.get(sidebar_data, :title) == "Templates" @@ -474,10 +475,10 @@ defmodule BDS.Desktop.ShellLive.SidebarComponents do %{ year: year, count: Enum.reduce(months, 0, fn entry, acc -> acc + (entry.count || 0) end), - months: Enum.sort_by(months, &-&1.month) + months: Enum.sort_by(months, &(-&1.month)) } end) - |> Enum.sort_by(&-&1.year) + |> Enum.sort_by(&(-&1.year)) end defp sidebar_filter_tag_color(filters_config, tag) do @@ -489,8 +490,11 @@ defmodule BDS.Desktop.ShellLive.SidebarComponents do defp sidebar_filter_chip_style(filters_config, tag) do case sidebar_filter_tag_color(filters_config, tag) do - nil -> nil - color -> "background-color: #{color}; color: #{sidebar_filter_contrast_color(color)}; border-color: #{color};" + nil -> + nil + + color -> + "background-color: #{color}; color: #{sidebar_filter_contrast_color(color)}; border-color: #{color};" end end @@ -544,7 +548,9 @@ defmodule BDS.Desktop.ShellLive.SidebarComponents do end defp sidebar_route_atom(route) when is_atom(route), do: route - defp sidebar_route_atom(route) when is_binary(route), do: String.to_existing_atom(route) + + defp sidebar_route_atom(route) when is_binary(route), + do: BDS.BoundedAtoms.editor_route(route, :dashboard) defp tab_id_for_route(route, id) do case Registry.editor_route(route) do diff --git a/lib/bds/desktop/shell_live/tab_helpers.ex b/lib/bds/desktop/shell_live/tab_helpers.ex index 20e701f..510304d 100644 --- a/lib/bds/desktop/shell_live/tab_helpers.ex +++ b/lib/bds/desktop/shell_live/tab_helpers.ex @@ -2,7 +2,7 @@ defmodule BDS.Desktop.ShellLive.TabHelpers do @moduledoc false alias BDS.Desktop.ShellData - alias BDS.{Media, Posts} + alias BDS.{BoundedAtoms, Media, Posts} alias BDS.Media.Media, as: MediaRecord alias BDS.Posts.Post alias BDS.UI.Registry @@ -42,7 +42,9 @@ defmodule BDS.Desktop.ShellLive.TabHelpers do def tab_icon_id(%{type: type}), do: Atom.to_string(type) def sidebar_route_atom(route) when is_atom(route), do: route - def sidebar_route_atom(route) when is_binary(route), do: String.to_existing_atom(route) + + def sidebar_route_atom(route) when is_binary(route), + do: BoundedAtoms.editor_route(route, :dashboard) def tab_id_for_route(route, id) do case Registry.editor_route(route) do diff --git a/lib/bds/mcp/queries.ex b/lib/bds/mcp/queries.ex index bd4384f..b9680de 100644 --- a/lib/bds/mcp/queries.ex +++ b/lib/bds/mcp/queries.ex @@ -72,7 +72,10 @@ defmodule BDS.MCP.Queries do |> Util.maybe_put(:category, Util.map_get(params, :category)) |> Util.maybe_put(:tags, Util.map_get(params, :tags)) |> Util.maybe_put(:language, Util.map_get(params, :language)) - |> Util.maybe_put(:missing_translation_language, Util.map_get(params, :missingTranslationLanguage)) + |> Util.maybe_put( + :missing_translation_language, + Util.map_get(params, :missingTranslationLanguage) + ) |> Util.maybe_put(:year, Util.map_get(params, :year)) |> Util.maybe_put(:month, Util.map_get(params, :month)) |> Util.maybe_put(:status, parse_status(Util.map_get(params, :status))) @@ -82,8 +85,7 @@ defmodule BDS.MCP.Queries do @spec parse_status(term()) :: atom() | nil def parse_status(nil), do: nil - def parse_status(status) when is_atom(status), do: status - def parse_status(status) when is_binary(status), do: String.to_existing_atom(status) + def parse_status(status), do: BDS.BoundedAtoms.post_status(status) @spec group_rows(Post.t(), [String.t()]) :: [map()] def group_rows(_post, []), do: [%{}] diff --git a/lib/bds/menu.ex b/lib/bds/menu.ex index c1485a2..063cac2 100644 --- a/lib/bds/menu.ex +++ b/lib/bds/menu.ex @@ -174,7 +174,9 @@ defmodule BDS.Menu do defp outline_kind(element), do: xml_attr(element, :type) || xml_attr(element, :kind) - defp outline_slug(element, :category_archive), do: xml_attr(element, :categoryName) || xml_attr(element, :slug) + defp outline_slug(element, :category_archive), + do: xml_attr(element, :categoryName) || xml_attr(element, :slug) + defp outline_slug(element, :home), do: xml_attr(element, :pageSlug) || xml_attr(element, :slug) defp outline_slug(element, _kind), do: xml_attr(element, :pageSlug) || xml_attr(element, :slug) @@ -203,15 +205,7 @@ defmodule BDS.Menu do defp normalize_kind(nil), do: :page defp normalize_kind(kind) when is_binary(kind) do - case kind do - "category-archive" -> :category_archive - other -> - other - |> String.to_existing_atom() - |> normalize_kind() - end - rescue - _error -> :page + BDS.BoundedAtoms.menu_kind(kind, :page) end defp normalize_optional_string(nil), do: nil diff --git a/lib/bds/posts/rebuild_from_files.ex b/lib/bds/posts/rebuild_from_files.ex index c6fd02a..22abaef 100644 --- a/lib/bds/posts/rebuild_from_files.ex +++ b/lib/bds/posts/rebuild_from_files.ex @@ -262,12 +262,10 @@ defmodule BDS.Posts.RebuildFromFiles do end @doc false - def parse_post_status(status) when is_atom(status), do: status - def parse_post_status(status), do: String.to_existing_atom(status) + def parse_post_status(status), do: BDS.BoundedAtoms.post_status(status, :draft) @doc false - def parse_translation_status(status) when is_atom(status), do: status - def parse_translation_status(status), do: String.to_existing_atom(status) + def parse_translation_status(status), do: BDS.BoundedAtoms.translation_status(status, :draft) @doc false def progress_callback(opts), do: ProgressReporter.callback(opts) diff --git a/lib/bds/ui/session.ex b/lib/bds/ui/session.ex index c507378..5d43ddf 100644 --- a/lib/bds/ui/session.ex +++ b/lib/bds/ui/session.ex @@ -1,6 +1,7 @@ defmodule BDS.UI.Session do @moduledoc false + alias BDS.BoundedAtoms alias BDS.UI.Workbench def serialize(state) do @@ -32,18 +33,19 @@ defmodule BDS.UI.Session do Workbench.new( sidebar_visible: Map.get(payload, "sidebar_visible", true), sidebar_width: Map.get(payload, "sidebar_width", 280), - active_view: atomize(Map.get(payload, "active_view"), :posts), + active_view: BoundedAtoms.sidebar_view(Map.get(payload, "active_view"), :posts), assistant_sidebar_visible: Map.get(payload, "assistant_sidebar_visible", false), assistant_sidebar_width: Map.get(payload, "assistant_sidebar_width", 360), panel_visible: get_in(payload, ["panel", "visible"]) || false, - panel_tab: atomize(get_in(payload, ["panel", "active_tab"]) || "tasks", :tasks), + panel_tab: + BoundedAtoms.panel_tab(get_in(payload, ["panel", "active_tab"]) || "tasks", :tasks), dirty_tabs: Enum.map(Map.get(payload, "dirty_tabs", []), &decode_tab_ref/1) ) tabs = Enum.map(Map.get(payload, "tabs", []), fn tab -> %{ - type: atomize(Map.get(tab, "type", "post"), :post), + type: BoundedAtoms.editor_route(Map.get(tab, "type", "post"), :post), id: Map.get(tab, "id"), is_transient: Map.get(tab, "is_transient", false) } @@ -58,15 +60,9 @@ defmodule BDS.UI.Session do defp encode_tab_ref({type, id}), do: %{"type" => Atom.to_string(type), "id" => id} defp decode_tab_ref(nil), do: nil - defp decode_tab_ref(%{"type" => type, "id" => id}), do: {atomize(type, :post), id} - defp atomize(value, _fallback) when is_atom(value), do: value - - defp atomize(value, fallback) when is_binary(value) do - String.to_existing_atom(value) - rescue - ArgumentError -> fallback - end + defp decode_tab_ref(%{"type" => type, "id" => id}), + do: {BoundedAtoms.editor_route(type, :post), id} defp active_route(nil), do: :dashboard defp active_route({type, _id}), do: type diff --git a/test/bds/bounded_atoms_test.exs b/test/bds/bounded_atoms_test.exs new file mode 100644 index 0000000..e5e49c8 --- /dev/null +++ b/test/bds/bounded_atoms_test.exs @@ -0,0 +1,54 @@ +defmodule BDS.BoundedAtomsTest do + use ExUnit.Case, async: true + + alias BDS.BoundedAtoms + + test "parses only explicit atoms from each bounded domain" do + assert BoundedAtoms.sidebar_view("posts") == :posts + assert BoundedAtoms.editor_route("metadata_diff") == :metadata_diff + assert BoundedAtoms.panel_tab("post_links") == :post_links + assert BoundedAtoms.post_status("archived") == :archived + assert BoundedAtoms.translation_status("published") == :published + assert BoundedAtoms.script_kind("transform") == :transform + assert BoundedAtoms.template_kind("not_found") == :not_found + assert BoundedAtoms.menu_kind("category-archive") == :category_archive + assert BoundedAtoms.import_section("taxonomy") == :taxonomy + assert BoundedAtoms.taxonomy_type("tags") == :tags + assert BoundedAtoms.ai_endpoint("airplane") == :airplane + assert BoundedAtoms.mcp_agent("github_copilot") == :github_copilot + assert BoundedAtoms.shell_command("toggle_panel") == :toggle_panel + end + + test "falls back without creating atoms for unknown strings" do + assert BoundedAtoms.sidebar_view("unknown", :posts) == :posts + assert BoundedAtoms.editor_route("unknown", :dashboard) == :dashboard + assert BoundedAtoms.panel_tab("unknown", :tasks) == :tasks + assert BoundedAtoms.post_status("unknown", :draft) == :draft + assert BoundedAtoms.translation_status("unknown", :draft) == :draft + assert BoundedAtoms.script_kind("unknown", :utility) == :utility + assert BoundedAtoms.template_kind("unknown", :post) == :post + assert BoundedAtoms.menu_kind("unknown", :page) == :page + assert BoundedAtoms.import_section("unknown") == nil + assert BoundedAtoms.taxonomy_type("unknown") == nil + assert BoundedAtoms.ai_endpoint("unknown") == nil + assert BoundedAtoms.mcp_agent("unknown") == nil + assert BoundedAtoms.shell_command("unknown") == nil + end + + test "codebase does not use String.to_existing_atom rescues" do + lib_dir = Path.expand("../../lib", __DIR__) + + offenders = + lib_dir + |> Path.join("**/*.ex") + |> Path.wildcard() + |> Enum.reject(&String.ends_with?(&1, "bounded_atoms.ex")) + |> Enum.filter(fn path -> + path + |> File.read!() + |> String.contains?("String.to_existing_atom") + end) + + assert offenders == [] + end +end