kash-shell 0.3.14__py3-none-any.whl → 0.3.16__py3-none-any.whl

kash/file_storage/file_store.py

@@ -16,7 +16,11 @@ from kash.config.logger import get_log_settings, get_logger
 from kash.config.text_styles import EMOJI_SAVED
 from kash.file_storage.item_file_format import read_item, write_item
 from kash.file_storage.metadata_dirs import MetadataDirs
-from kash.file_storage.store_filenames import folder_for_type, join_suffix, parse_item_filename
+from kash.file_storage.store_filenames import (
+    folder_for_type,
+    join_suffix,
+    parse_item_filename,
+)
 from kash.model.items_model import Item, ItemId, ItemType
 from kash.model.paths_model import StorePath
 from kash.shell.output.shell_output import PrintHooks
@@ -39,7 +43,9 @@ T = TypeVar("T")
 P = ParamSpec("P")
 
 
-def synchronized(method: Callable[Concatenate[SelfT, P], T]) -> Callable[Concatenate[SelfT, P], T]:
+def synchronized(
+    method: Callable[Concatenate[SelfT, P], T],
+) -> Callable[Concatenate[SelfT, P], T]:
     """
     Simple way to synchronize a few methods.
     """
@@ -142,7 +148,10 @@ class FileStore(Workspace):
         """
         name, item_type, _format, file_ext = parse_item_filename(store_path)
         if not file_ext:
-            log.debug("Skipping file with unrecognized name or extension: %s", fmt_path(store_path))
+            log.debug(
+                "Skipping file with unrecognized name or extension: %s",
+                fmt_path(store_path),
+            )
             return None
 
         full_suffix = join_suffix(item_type.name, file_ext.name) if item_type else file_ext.name
@@ -158,11 +167,17 @@ class FileStore(Workspace):
                 if old_path and old_path != store_path:
                     dup_path = old_path
                     log.info(
-                        "Duplicate items (%s):\n%s", item_id, fmt_lines([old_path, store_path])
+                        "Duplicate items (%s):\n%s",
+                        item_id,
+                        fmt_lines([old_path, store_path]),
                     )
                 self.id_map[item_id] = store_path
-        except SkippableError as e:
-            log.warning("Could not read file, skipping: %s: %s", fmt_path(store_path), e)
+        except (ValueError, SkippableError) as e:
+            log.warning(
+                "Could not load file, skipping from store index: %s: %s",
+                fmt_path(store_path),
+                e,
+            )
 
         return dup_path
 
@@ -182,7 +197,7 @@ class FileStore(Workspace):
         except (FileNotFoundError, InvalidFilename):
             pass
 
-    def resolve_path(self, path: Path | StorePath) -> StorePath | None:
+    def resolve_to_store_path(self, path: Path | StorePath) -> StorePath | None:
         """
         Return a StorePath if the given path is within the store, otherwise None.
         If it is already a StorePath, return it unchanged.
@@ -195,6 +210,21 @@ class FileStore(Workspace):
         else:
             return None
 
+    def resolve_to_abs_path(self, path: Path | StorePath) -> Path:
+        """
+        Return an absolute path, resolving any store paths to within the store
+        and resolving other paths like regular `Path.resolve()`.
+        """
+        store_path = self.resolve_to_store_path(path)
+        if store_path:
+            return self.base_dir / store_path
+        elif path.is_absolute():
+            return path
+        else:
+            # Unspecified relative paths resolved to cwd.
+            # TODO: Consider if such paths might be store paths.
+            return path.resolve()
+
     def exists(self, store_path: StorePath) -> bool:
         """
         Check given store path refers to an existing file.
@@ -204,13 +234,17 @@ class FileStore(Workspace):
     @synchronized
     def _pick_filename_for(self, item: Item, *, overwrite: bool = False) -> tuple[str, str | None]:
         """
-        Get a suitable filename for this item.
-        If `overwrite` is true, use the the slugified title.
-        If it is false, use the slugified title with a suffix to make it unique
-        and in this case returns the old filename for this item, if it is different.
+        Get a suitable filename for this item. If `overwrite` is true, use the the slugified
+        title, regardless of whether it is already in the store.
+        If `overwrite` is false, use the slugified title with a suffix to make it unique
+        (and in this case also return the old filename for this item).
         """
         if overwrite:
-            log.info("Picked default filename: %s for item: %s", item.default_filename(), item)
+            log.info(
+                "Picked default filename: %s for item: %s",
+                item.default_filename(),
+                item,
+            )
             return item.default_filename(), None
 
         slug = item.slug_name()
@@ -268,14 +302,13 @@ class FileStore(Workspace):
     @synchronized
     def store_path_for(
         self, item: Item, *, as_tmp: bool = False, overwrite: bool = False
-    ) -> tuple[StorePath, bool, StorePath | None]:
+    ) -> tuple[StorePath, StorePath | None]:
         """
         Return the store path for an item. If the item already has a `store_path`, we use that.
         Otherwise we need to find the store path or generate a new one that seems suitable.
 
-        Returns `store_path, found, old_store_path` where `found` indicates whether the path was
-        already found (in the item or in the store by checking for identity) and `old_store_path`
-        is the previous similarly named item with a different identity (or None there is none).
+        Returns `store_path, old_store_path` where `old_store_path` is the previous similarly
+        named item with a different identity (or None there is none).
 
         If `as_tmp` is true, will return a path from the temporary directory in the store.
         Normally an item is always saved to a unique store path but if `overwrite` is true,
@@ -284,17 +317,17 @@ class FileStore(Workspace):
         item_id = item.item_id()
         old_filename = None
         if as_tmp:
-            return self._tmp_path_for(item), False, None
+            return self._tmp_path_for(item), None
         elif item.store_path:
-            return StorePath(item.store_path), True, None
+            return StorePath(item.store_path), None
         elif item_id in self.id_map and self.exists(self.id_map[item_id]):
             # If this item has an identity and we've saved under that id before, use the same store path.
             store_path = self.id_map[item_id]
             log.info(
-                "Found existing item with same id:\n%s",
+                "When picking a store path, found an existing item with same id:\n%s",
                 fmt_lines([fmt_loc(store_path), item_id]),
             )
-            return store_path, True, None
+            return store_path, None
         else:
             # We need to pick the path and filename.
             folder_path = folder_for_type(item.type)
@@ -305,14 +338,14 @@ class FileStore(Workspace):
             if old_filename and Path(self.base_dir / folder_path / old_filename).exists():
                 old_store_path = StorePath(folder_path / old_filename)
 
-            return StorePath(store_path), False, old_store_path
+            return StorePath(store_path), old_store_path
 
     def _tmp_path_for(self, item: Item) -> StorePath:
         """
         Find a path for an item in the tmp directory.
         """
         if not item.store_path:
-            store_path, _found, _old = self.store_path_for(item, as_tmp=False)
+            store_path, _old = self.store_path_for(item, as_tmp=False)
             return StorePath(self.dirs.tmp_dir / store_path)
         elif (self.base_dir / item.store_path).is_relative_to(self.dirs.tmp_dir):
             return StorePath(item.store_path)
@@ -331,14 +364,14 @@ class FileStore(Workspace):
         item: Item,
         *,
         overwrite: bool = False,
-        skip_dup_names: bool = False,
         as_tmp: bool = False,
         no_format: bool = False,
         no_frontmatter: bool = False,
     ) -> StorePath:
         """
         Save the item. Uses the `store_path` if it's already set or generates a new one.
-        Updates `item.store_path`.
+        Updates `item.store_path`. An existing file can be added by having the item's
+        `external_path` set to a location (inside or outside the store).
 
         Unless `no_format` is true, also normalizes body text formatting (for Markdown)
         and updates the item's body to match.
@@ -348,65 +381,62 @@ class FileStore(Workspace):
         If `overwrite` is true, will overwrite a file that has the same path.
 
         If `as_tmp` is true, will save the item to a temporary file.
-
-        If `skip_dup_names` is true, will skip saving if an item if an item with a
-        matching path (based on its title) already exists.
         """
-        if overwrite and skip_dup_names:
-            raise ValueError("Cannot both overwrite and skip duplicate names.")
         if overwrite and as_tmp:
             raise ValueError("Cannot both overwrite and save to a temporary file.")
 
-        # If external file already exists within the workspace, the file is already saved (without metadata).
+        # If external path already exists and is within the workspace, the file was
+        # already saved (e.g. by an action that wrote the item directly to the store).
         external_path = item.external_path and Path(item.external_path).resolve()
         if external_path and self._is_in_store(external_path):
-            log.message("External file already saved: %s", fmt_loc(external_path))
+            log.info("Item with external_path already saved: %s", fmt_loc(external_path))
             rel_path = external_path.relative_to(self.base_dir)
-            # Indicate this is really an item with a store path, not an external path.
+            # Indicate this is an item with a store path, not an external path.
+            # Keep external_path set so we know body is in that file.
             item.store_path = str(rel_path)
-            item.external_path = None
             return StorePath(rel_path)
         else:
             # Otherwise it's still in memory or in a file outside the workspace and we need to save it.
-            store_path, found, old_store_path = self.store_path_for(
+            store_path, old_store_path = self.store_path_for(
                 item, as_tmp=as_tmp, overwrite=overwrite
             )
 
-            if skip_dup_names and found:
-                log.message(
-                    "Skipping save because an item of the same name already exists: %s",
-                    fmt_loc(store_path),
-                )
-                item.store_path = str(store_path)
-                return store_path
-
             full_path = self.base_dir / store_path
 
-            log.info("Saving item to %s: %s", fmt_loc(full_path), item)
+            supports_frontmatter = item.format and item.format.supports_frontmatter
+            log.info(
+                "Saving item in format %s (supports_frontmatter=%s) to %s: %s",
+                item.format,
+                supports_frontmatter,
+                fmt_loc(full_path),
+                item,
+            )
 
-            # If we're overwriting an existing file, archive it first.
+            # If we're overwriting an existing file, archive it first so it is in the archive, not lost.
             if full_path.exists():
                 try:
+                    log.info(
+                        "Previous file exists so will archive it: %s",
+                        fmt_loc(store_path),
+                    )
                     self.archive(store_path, quiet=True)
                 except Exception as e:
                     log.info("Exception archiving existing file: %s", e)
 
             # Now save the new item.
             try:
-                supports_frontmatter = item.format and item.format.supports_frontmatter
-                # For binary or unknown formats or if we're not adding frontmatter, copy the file exactly.
+                # For binary or unknown formats or if we're not adding frontmatter, copy the file.
                 if item.external_path and (no_frontmatter or not supports_frontmatter):
+                    log.info(
+                        "Path is an external path, so copying: %s -> %s",
+                        fmt_path(item.external_path),
+                        fmt_path(full_path),
+                    )
                     copyfile_atomic(item.external_path, full_path, make_parents=True)
                 else:
                     # Save as a text item with frontmatter.
                     if item.external_path:
                         item.body = Path(item.external_path).read_text()
-                    if overwrite and full_path.exists():
-                        log.info(
-                            "Overwrite is enabled and a previous file exists so will archive it: %s",
-                            fmt_loc(store_path),
-                        )
-                        self.archive(store_path, quiet=True)
                     write_item(item, full_path, normalize=not no_format)
             except OSError as e:
                 log.error("Error saving item: %s", e)
@@ -530,7 +560,7 @@ class FileStore(Workspace):
             else:
                 # Binary or other files we just copy over as-is, preserving the name.
                 # We know the extension is recognized.
-                store_path, _found, old_store_path = self.store_path_for(item)
+                store_path, old_store_path = self.store_path_for(item)
                 if self.exists(store_path):
                     raise FileExists(f"Resource already in store: {fmt_loc(store_path)}")
 
@@ -675,7 +705,10 @@ class FileStore(Workspace):
         for warning in self.warnings:
             log.warning("%s", warning)
 
-        log.info("File store startup took %s.", format_duration(self.end_time - self.start_time))
+        log.info(
+            "File store startup took %s.",
+            format_duration(self.end_time - self.start_time),
+        )
         # TODO: Log more info like number of items by type.
         return True
 

kash/file_storage/item_file_format.py

@@ -28,8 +28,6 @@ def write_item(item: Item, path: Path, normalize: bool = True):
     By default normalizes formatting of the body text and updates the item's body.
     """
     item.validate()
-    if item.is_binary:
-        raise ValueError(f"Binary items should be external files: {item}")
     if item.format and not item.format.supports_frontmatter:
         raise ValueError(f"Item format `{item.format.value}` does not support frontmatter: {item}")
 

kash/local_server/local_server_routes.py

@@ -244,7 +244,7 @@ def _serve_item(
             media_type=mime_type,
         )
     else:
-        display_title = item.display_title() if item else str(path)
+        display_title = item.pick_title() if item else str(path)
 
         # For HEAD requests, return header with mime type only.
         if request.method == "HEAD":

kash/model/actions_model.py

@@ -22,7 +22,7 @@ from kash.exec_model.shell_model import ShellResult
 from kash.llm_utils import LLM, LLMName
 from kash.llm_utils.llm_messages import Message, MessageTemplate
 from kash.model.exec_model import ExecContext
-from kash.model.items_model import UNTITLED, Item, ItemType
+from kash.model.items_model import UNTITLED, Format, Item, ItemType
 from kash.model.operations_model import Operation, Source
 from kash.model.params_model import (
     ALL_COMMON_PARAMS,
@@ -102,6 +102,10 @@ class ActionResult:
     shell_result: ShellResult | None = None
     """Customize control of how the action's result is displayed in the shell."""
 
+    def get_by_format(self, format: Format) -> Item:
+        """Convenience method to get an item for actions that return multiple formats."""
+        return next(item for item in self.items if item.format == format)
+
     def has_hints(self) -> bool:
         return bool(
             self.replaces_input or self.skip_duplicates or self.path_ops or self.shell_result

kash/model/items_model.py

@@ -219,6 +219,12 @@ class Item:
     a text document, PDF or other resource, URL, etc.
     """
 
+    # TODO: A few cleanups:
+    # - Consider adding aliases and tags. See also Obsidian frontmatter format:
+    #   https://help.obsidian.md/Editing+and+formatting/Properties#Default%20properties
+    # - Can eliminate context here as we now have ExectContext in a contextvar.
+    # - Change store_path and external_path to a StorePath and Path instead of a str.
+
     type: ItemType
     state: State = State.draft
     title: str | None = None
@@ -230,17 +236,15 @@ class Item:
     created_at: datetime = field(default_factory=lambda: datetime.now(UTC))
     modified_at: datetime | None = None
 
-    # TODO: Consider adding aliases and tags. See also Obsidian frontmatter format:
-    # https://help.obsidian.md/Editing+and+formatting/Properties#Default%20properties
-
     # Content of the item.
     # Text items are in body. Large or binary items may be stored externally.
+    # The external_path if present should always hold the current body of the content
+    # (and body will not be set). This is necessary for large or binary files.
     body: str | None = None
     external_path: str | None = None
     original_filename: str | None = None
 
     # Path to the item in the store, if it has been saved.
-    # TODO: Migrate this to StorePath.
     store_path: str | None = None
 
     # Optionally, relations to other items, including any time this item is derived from.
@@ -547,7 +551,7 @@ class Item:
         if filename_stem and not prefer_title:
             return slugify_snake(filename_stem)
         else:
-            return slugify_snake(self.abbrev_title(max_len=max_len, add_ops_suffix=True))
+            return slugify_snake(self.pick_title(max_len=max_len, add_ops_suffix=True))
 
     def default_filename(self) -> str:
         """
@@ -560,7 +564,16 @@ class Item:
         full_suffix = self.get_full_suffix()
         return join_suffix(slug, full_suffix)
 
-    def abbrev_title(
+    def body_heading(self, allowed_tags: tuple[str, ...] = ("h1", "h2")) -> str | None:
+        """
+        Get the first heading (by default h1 or h2) from the body text, if present.
+        """
+        if self.format in [Format.markdown, Format.md_html]:
+            return first_heading(self.body_text(), allowed_tags=allowed_tags)
+        # TODO: Support HTML <h1> and <h2> as well.
+        return None
+
+    def pick_title(
         self,
         *,
         max_len: int = 100,
@@ -619,41 +632,20 @@ class Item:
 
         return final_text
 
-    def display_title(self) -> str:
-        """
-        A display title for this item. Same as abbrev_title() but will fall back
-        to the filename if it is available.
-        """
-        display_title = self.title
-        if not display_title and self.store_path:
-            display_title = Path(self.store_path).name
-        if not display_title:
-            display_title = self.abbrev_title()
-        return display_title
-
-    def abbrev_description(self, max_len: int = 1000) -> str:
+    def pick_description(self, max_len: int = 1000) -> str:
         """
         Get or infer description.
         """
         return abbrev_on_words(html_to_plaintext(self.description or self.body or ""), max_len)
 
-    def body_heading(self) -> str | None:
-        """
-        Get the first h1 or h2 heading from the body text, if present.
-        """
-        if self.format in [Format.markdown, Format.md_html]:
-            return first_heading(self.body_text(), allowed_tags=("h1", "h2"))
-        # TODO: Support HTML <h1> and <h2> as well.
-        return None
-
     def abbrev_body(self, max_len: int) -> str:
         """
         Get an abbreviated version of the body text. Must not be a binary Item.
         Abbreviates YAML bodies like {"role": "user", "content": "Hello"} to "user Hello".
         """
-        body_text = self.body_text()[:max_len]
+        body_text = abbrev_str(self.body_text(), max_len)
 
-        # Just for aesthetics especially for titles of chat files.
+        # Just for aesthetics, especially for titles of chat files.
         if self.type in [ItemType.chat, ItemType.config] or self.format == Format.yaml:
             try:
                 yaml_obj = list(new_yaml().load_all(self.body_text()))
@@ -662,7 +654,7 @@ class Item:
             except Exception as e:
                 log.info("Error parsing YAML body: %s", e)
 
-        return body_text[:max_len]
+        return abbrev_str(body_text, max_len)
 
     @property
     def has_body(self) -> bool:
@@ -745,9 +737,14 @@ class Item:
         self,
         other: Item | None = None,
         update_timestamp: bool = False,
+        clear_fields=(
+            "store_path",  # Will be set at save time.
+            "source",  # Should be cleared so the ItemId of a copy is not the same as the original.
+            "modified_at",
+        ),
         **other_updates: Unpack[ItemUpdateOptions],
     ) -> dict[str, Any]:
-        overrides: dict[str, Any] = {"store_path": None, "modified_at": None}
+        overrides: dict[str, Any] = {f: None for f in clear_fields}
         if update_timestamp:
             overrides["created_at"] = datetime.now()
 
@@ -767,8 +764,9 @@ class Item:
         self, update_timestamp: bool = True, **other_updates: Unpack[ItemUpdateOptions]
     ) -> Item:
         """
-        Copy item with the given field updates. Resets `store_path` to None but preserves
-        other fields, including the body. Updates created time if requested.
+        Copy item with the given field updates. Resets `store_path` and `source` to None
+        since those should be set explicitly later. Preserves other fields, including
+        the body.
         """
         new_fields = self._copy_and_update(update_timestamp=update_timestamp, **other_updates)
         return Item(**new_fields)
@@ -783,9 +781,12 @@ class Item:
 
     def derived_copy(self, **updates: Unpack[ItemUpdateOptions]) -> Item:
         """
-        Same as `new_copy_with()`, but also makes any other updates and updates the
-        `derived_from` relation. If we also have an action context, then use the
-        `title_template` to derive a new title.
+        Copy item with the given field updates. Resets `store_path` and `source` to None
+        since those should be set explicitly later. Preserves other fields, including
+        the body.
+
+        Same as `new_copy_with` but also updates the `derived_from` relation. If we also
+        have an action context, then use the `title_template` to derive a new title.
         """
         if not self.store_path:
             if self.relations.derived_from:
@@ -898,7 +899,7 @@ class Item:
         elif self.external_path:
             return fmt_loc(self.external_path)
         else:
-            return repr(self.abbrev_title())
+            return repr(self.pick_title())
 
     def as_chat_history(self) -> ChatHistory:
         if self.type != ItemType.chat:

kash/shell/completions/shell_completions.py

@@ -270,7 +270,7 @@ def get_item_completions(
                 f"{fmt_store_path(not_none(item.store_path))}",
                 COMPLETION_DISPLAY_MAX_LEN,
             ),
-            description=item.abbrev_title(),
+            description=item.pick_title(),
             append_space=True,
             score=score,
         )

kash/utils/file_utils/file_formats_model.py

@@ -106,7 +106,9 @@ class Format(Enum):
     @property
     def is_simple_text(self) -> bool:
         """
-        Is this plaintext or close to it, like Markdown?
+        Is this plaintext or close to it, like Markdown or Markdown with limited HTML?
+        "Simple text" should be a format that converts canonically to clean HTML.
+        Does not include full-page general HTML.
         """
         return self in [self.plaintext, self.markdown, self.md_html]
 
@@ -143,17 +145,23 @@ class Format(Enum):
 
     @property
     def is_markdown(self) -> bool:
-        """Is in pure Markdown (no HTML)."""
+        """Is this pure Markdown? Does not include Markdown mixed with HTML."""
         return self in [self.markdown]
 
     @property
     def is_markdown_with_html(self) -> bool:
-        """Is in Markdown with HTML."""
+        """Is this Markdown mixed with HTML?"""
         return self in [self.md_html]
 
     @property
     def is_html(self) -> bool:
-        return self in [self.html, self.md_html]
+        """Is this format HTML? Does not include Markdown mixed with HTML."""
+        return self in [self.html]
+
+    @property
+    def is_html_compatible(self) -> bool:
+        """Is this format directly compatible with HTML (any combination of text, markdown, or HTML)?"""
+        return self in [self.plaintext, self.markdown, self.md_html, self.html]
 
     @property
     def is_data(self) -> bool:
@@ -168,8 +176,8 @@ class Format(Enum):
         """
         Is this format compatible with frontmatter format metadata?
         PDF and docx unfortunately won't work with frontmatter.
-        CSV does to some degree, depending on the tool, and this is useful so we support it.
-        Perhaps we could include JSON here (assuming it's JSON5), but currently we do not.
+        CSV does to some degree, depending on the tool, and this can be useful so we support it.
+        Including JSON here (assuming it's JSON5) for similar reasons.
         """
         return self in [
             self.url,
@@ -183,7 +191,7 @@ class Format(Enum):
             self.python,
             self.shellscript,
             self.xonsh,
-            self.csv,
+            self.csv,  # Often but not always supported.
             self.log,
         ]
 

kash/utils/text_handling/doc_normalization.py

@@ -9,6 +9,13 @@ from kash.utils.file_utils.file_formats_model import Format, detect_file_format
 from kash.utils.rich_custom.ansi_cell_len import ansi_cell_len
 
 
+def can_normalize(format: Format) -> bool:
+    """
+    True for Markdown (the only format we currently normalize).
+    """
+    return format == Format.markdown or format == Format.md_html
+
+
 def normalize_formatting(
     text: str,
     format: Format | None,

kash/web_gen/simple_webpage.py

@@ -7,6 +7,7 @@ def simple_webpage_render(
     item: Item,
     page_template: str = "simple_webpage.html.jinja",
     add_title_h1: bool = True,
+    show_theme_toggle: bool = False,
 ) -> str:
     """
     Generate a simple web page from a single item.
@@ -15,10 +16,12 @@ def simple_webpage_render(
     return render_web_template(
         template_filename=page_template,
         data={
-            "title": item.abbrev_title(),
+            "title": item.pick_title(),
             "add_title_h1": add_title_h1,
             "content_html": item.body_as_html(),
             "thumbnail_url": item.thumbnail_url,
+            "enable_themes": show_theme_toggle,
+            "show_theme_toggle": show_theme_toggle,
         },
     )
 

kash/web_gen/tabbed_webpage.py

@@ -68,14 +68,14 @@ def tabbed_webpage_config(
 
     tabs = [
         TabInfo(
-            label=clean_label(item.abbrev_title()),
+            label=clean_label(item.pick_title()),
             store_path=item.store_path,
             thumbnail_url=get_thumbnail_url(item),
         )
         for item in items
     ]
     _fill_in_ids(tabs)
-    title = summary_heading([item.abbrev_title() for item in items])
+    title = summary_heading([item.pick_title() for item in items])
     config = TabbedWebpage(
         title=title, tabs=tabs, show_tabs=len(tabs) > 1, add_title_h1=add_title_h1
     )
@@ -100,7 +100,10 @@ def _load_tab_content(config: TabbedWebpage):
 
 
 def tabbed_webpage_generate(
-    config_item: Item, page_template: str = "base_webpage.html.jinja", add_title_h1: bool = True
+    config_item: Item,
+    page_template: str = "base_webpage.html.jinja",
+    add_title_h1: bool = True,
+    show_theme_toggle: bool = False,
 ) -> str:
     """
     Generate a web page using the supplied config.
@@ -121,6 +124,8 @@ def tabbed_webpage_generate(
             "title": tabbed_webpage.title,
             "add_title_h1": add_title_h1,
             "content": content,
+            "enable_themes": show_theme_toggle,
+            "show_theme_toggle": show_theme_toggle,
         },
     )