kash-shell 0.3.13__py3-none-any.whl → 0.3.15__py3-none-any.whl

kash/actions/core/markdownify.py

@@ -1,8 +1,9 @@
 from kash.config.logger import get_logger
 from kash.exec import kash_action
 from kash.exec.preconditions import has_html_body, is_url_resource
+from kash.exec.runtime_settings import current_runtime_settings
 from kash.model import Format, Item
-from kash.model.params_model import common_params
+from kash.model.items_model import ItemType
 from kash.utils.text_handling.markdownify_utils import markdownify_custom
 from kash.web_content.file_cache_utils import get_url_html
 from kash.web_content.web_extract_readabilipy import extract_text_readabilipy
@@ -12,20 +13,22 @@ log = get_logger(__name__)
 
 @kash_action(
     precondition=is_url_resource | has_html_body,
-    params=common_params("refetch"),
     mcp_tool=True,
 )
-def markdownify(item: Item, refetch: bool = False) -> Item:
+def markdownify(item: Item) -> Item:
     """
     Converts a URL or raw HTML item to Markdown, fetching with the content
     cache if needed. Also uses readability to clean up the HTML.
     """
 
+    refetch = current_runtime_settings().refetch
     expiration_sec = 0 if refetch else None
     url, html_content = get_url_html(item, expiration_sec=expiration_sec)
     page_data = extract_text_readabilipy(url, html_content)
     assert page_data.clean_html
     markdown_content = markdownify_custom(page_data.clean_html)
 
-    output_item = item.derived_copy(format=Format.markdown, body=markdown_content)
+    output_item = item.derived_copy(
+        type=ItemType.doc, format=Format.markdown, body=markdown_content
+    )
     return output_item

kash/actions/core/readability.py

@@ -1,8 +1,8 @@
 from kash.config.logger import get_logger
 from kash.exec import kash_action
 from kash.exec.preconditions import has_html_body, is_url_resource
+from kash.exec.runtime_settings import current_runtime_settings
 from kash.model import Format, Item
-from kash.model.params_model import common_params
 from kash.web_content.file_cache_utils import get_url_html
 from kash.web_content.web_extract_readabilipy import extract_text_readabilipy
 
@@ -11,14 +11,15 @@ log = get_logger(__name__)
 
 @kash_action(
     precondition=is_url_resource | has_html_body,
-    params=common_params("refetch"),
     mcp_tool=True,
 )
-def readability(item: Item, refetch: bool = False) -> Item:
+def readability(item: Item) -> Item:
     """
     Extracts clean HTML from a raw HTML item.
     See `markdownify` to also convert to Markdown.
     """
+
+    refetch = current_runtime_settings().refetch
     expiration_sec = 0 if refetch else None
     locator, html_content = get_url_html(item, expiration_sec=expiration_sec)
     page_data = extract_text_readabilipy(locator, html_content)

kash/actions/core/render_as_html.py

@@ -1,7 +1,7 @@
 from kash.actions.core.tabbed_webpage_config import tabbed_webpage_config
 from kash.actions.core.tabbed_webpage_generate import tabbed_webpage_generate
 from kash.exec import kash_action
-from kash.exec.preconditions import has_full_html_page_body, has_html_body, has_simple_text_body
+from kash.exec.preconditions import has_fullpage_html_body, has_html_body, has_simple_text_body
 from kash.exec_model.args_model import ONE_OR_MORE_ARGS
 from kash.model import ActionInput, ActionResult, Param
 from kash.model.items_model import ItemType
@@ -11,7 +11,7 @@ from kash.web_gen.simple_webpage import simple_webpage_render
 
 @kash_action(
     expected_args=ONE_OR_MORE_ARGS,
-    precondition=(has_html_body | has_simple_text_body) & ~has_full_html_page_body,
+    precondition=(has_html_body | has_simple_text_body) & ~has_fullpage_html_body,
     params=(Param("no_title", "Don't add a title to the page body.", type=bool),),
 )
 def render_as_html(input: ActionInput, no_title: bool = False) -> ActionResult:

kash/actions/core/show_webpage.py

@@ -1,7 +1,7 @@
 from kash.actions.core.render_as_html import render_as_html
 from kash.commands.base.show_command import show
 from kash.exec import kash_action
-from kash.exec.preconditions import has_full_html_page_body, has_html_body, has_simple_text_body
+from kash.exec.preconditions import has_fullpage_html_body, has_html_body, has_simple_text_body
 from kash.exec_model.args_model import ONE_OR_MORE_ARGS
 from kash.exec_model.commands_model import Command
 from kash.exec_model.shell_model import ShellResult
@@ -10,7 +10,7 @@ from kash.model import ActionInput, ActionResult
 
 @kash_action(
     expected_args=ONE_OR_MORE_ARGS,
-    precondition=(has_html_body | has_simple_text_body) & ~has_full_html_page_body,
+    precondition=(has_html_body | has_simple_text_body) & ~has_fullpage_html_body,
 )
 def show_webpage(input: ActionInput) -> ActionResult:
     """

kash/commands/workspace/selection_commands.py

@@ -7,6 +7,7 @@ from strif import copyfile_atomic
 
 from kash.config.logger import get_logger
 from kash.exec import kash_command
+from kash.exec.resolve_args import assemble_path_args
 from kash.exec_model.shell_model import ShellResult
 from kash.model.paths_model import StorePath
 from kash.shell.ui.shell_results import shell_print_selection_history
@@ -30,6 +31,7 @@ def select(
     clear_all: bool = False,
     clear_future: bool = False,
     refresh: bool = False,
+    no_check: bool = False,
 ) -> ShellResult:
     """
     Set or show the current selection.
@@ -51,6 +53,7 @@ def select(
     :param clear_all: Clear the full selection history.
     :param clear_future: Clear all selections from history after the current one.
     :param refresh: Refresh the current selection to drop any paths that no longer exist.
+    :param no_check: Do not check if the paths exist.
     """
     ws = current_ws()
 
@@ -68,6 +71,10 @@ def select(
         raise InvalidInput("Cannot combine multiple flags")
     if paths and any(exclusive_flags):
         raise InvalidInput("Cannot combine paths with other flags")
+    if not no_check:
+        for path in paths:
+            if not Path(ws.base_dir / path).exists():
+                raise InvalidInput(f"Path does not exist: {fmt_loc(path)}")
 
     if paths:
         store_paths = [StorePath(path) for path in paths]
@@ -203,3 +210,18 @@ def save(parent: str | None = None, to: str | None = None, no_frontmatter: bool
         for store_path in store_paths:
             target_path = target_dir / basename(store_path)
             copy_file(store_path, target_path)
+
+
+@kash_command
+def show_parent_dir(*paths: str) -> None:
+    """
+    Show the parent directory of the first item in the current selection.
+    """
+    from kash.commands.base.show_command import show
+
+    input_paths = assemble_path_args(*paths)
+    if not input_paths:
+        raise InvalidInput("No paths provided")
+
+    input_path = current_ws().resolve_to_abs_path(input_paths[0])
+    show(input_path.parent)

kash/commands/workspace/workspace_commands.py

@@ -59,6 +59,7 @@ from kash.utils.errors import InvalidInput
 from kash.utils.file_formats.chat_format import tail_chat_history
 from kash.utils.file_utils.dir_info import is_nonempty_dir
 from kash.utils.file_utils.file_formats_model import Format
+from kash.utils.text_handling.doc_normalization import can_normalize
 from kash.web_content.file_cache_utils import cache_file
 from kash.workspaces import (
     current_ws,
@@ -189,56 +190,80 @@ def cache_content(*urls_or_paths: str, refetch: bool = False) -> None:
 
 
 @kash_command
-def download(*urls_or_paths: str, refetch: bool = False) -> ShellResult:
+def download(*urls_or_paths: str, refetch: bool = False, no_format: bool = False) -> ShellResult:
     """
     Download a URL or resource. Uses cached content if available, unless `refetch` is true.
     Inputs can be URLs or paths to URL resources.
-    """
-    expiration_sec = 0 if refetch else None
+    Creates both resource and document versions for text content.
 
-    # TODO: Add option to include frontmatter metadata for text files.
+    :param no_format: If true, do not also normalize Markdown content.
+    """
     ws = current_ws()
     saved_paths = []
+
     for url_or_path in urls_or_paths:
         locator = resolve_locator_arg(url_or_path)
         url: Url | None = None
+
+        # Get the URL from the locator
         if not isinstance(locator, Path) and is_url(locator):
             url = Url(locator)
-        if isinstance(locator, StorePath):
+        elif isinstance(locator, StorePath):
             url_item = ws.load(locator)
             if is_url_resource(url_item):
                 url = url_item.url
+
         if not url:
             raise InvalidInput(f"Not a URL or URL resource: {fmt_loc(locator)}")
 
+        # Handle media URLs differently
         if is_media_url(url):
             log.message(
                 "URL is a media URL, so adding as a resource and will cache media: %s", fmt_loc(url)
             )
-            store_path = ws.import_item(locator, as_type=ItemType.resource)
+            store_path = ws.import_item(url, as_type=ItemType.resource, reimport=refetch)
+            saved_paths.append(store_path)
             media_tools.cache_media(url)
         else:
-            log.message("Will cache file and save to workspace: %s", fmt_loc(url))
-            original_filename = Path(parse_http_url(url).path).name
+            # Cache the content first
+            expiration_sec = 0 if refetch else None
             cache_result = cache_file(url, expiration_sec=expiration_sec)
-            # If available, use the mime type to help set item file extension.
+            original_filename = Path(parse_http_url(url).path).name
             mime_type = cache_result.content.headers and cache_result.content.headers.mime_type
-            item = Item.from_external_path(
+
+            # Create a resource item
+            resource_item = Item.from_external_path(
                 cache_result.content.path,
                 ItemType.resource,
+                url=url,
                 mime_type=mime_type,
                 original_filename=original_filename,
             )
-            store_path = ws.save(item)
+            # For initial content, do not format or add frontmatter.
+            store_path = ws.save(resource_item, no_frontmatter=True, no_format=True)
             saved_paths.append(store_path)
+            select(store_path)
+
+            # Also create a doc version for text content if we want to normalize formatting.
+            if resource_item.format and can_normalize(resource_item.format) and not no_format:
+                doc_item = Item.from_external_path(
+                    cache_result.content.path,
+                    ItemType.doc,
+                    url=url,
+                    mime_type=mime_type,
+                    original_filename=original_filename,
+                )
+                # Now use default formatting and frontmatter.
+                doc_store_path = ws.save(doc_item)
+                saved_paths.append(doc_store_path)
+                select(doc_store_path)
 
     print_status(
         "Downloaded %s %s:\n%s",
-        len(urls_or_paths),
-        plural("item", len(urls_or_paths)),
+        len(saved_paths),
+        plural("item", len(saved_paths)),
         fmt_lines(saved_paths),
     )
-    select(*saved_paths)
 
     return ShellResult(show_selection=True)
 
@@ -483,7 +508,7 @@ def import_item(
 
 
 @kash_command
-def import_clipboard(
+def save_clipboard(
     title: str | None = "pasted_text",
     type: ItemType = ItemType.resource,
     format: Format = Format.plaintext,
@@ -518,8 +543,6 @@ def fetch_metadata(*files_or_urls: str, refetch: bool = False) -> ShellResult:
 
     Skips items that already have a title and description, unless `refetch` is true.
     Skips (with a warning) items that are not URL resources.
-
-    :param use_cache: If true, also save page in content cache.
     """
     if not files_or_urls:
         locators = assemble_store_path_args()
@@ -529,12 +552,12 @@ def fetch_metadata(*files_or_urls: str, refetch: bool = False) -> ShellResult:
     store_paths = []
     for locator in locators:
         try:
-            if isinstance(locator, Path):
-                raise InvalidInput()
             fetched_item = fetch_url_metadata(locator, refetch=refetch)
             store_paths.append(fetched_item.store_path)
-        except InvalidInput:
-            log.warning("Not a URL or URL resource, will not fetch metadata: %s", fmt_loc(locator))
+        except InvalidInput as e:
+            log.warning(
+                "Not a URL or URL resource, will not fetch metadata: %s: %s", fmt_loc(locator), e
+            )
 
     if store_paths:
         select(*store_paths)
@@ -716,7 +739,7 @@ def reset_ignore_file(append: bool = False) -> None:
     ignore_path = ws.base_dir / ws.dirs.ignore_file
     write_ignore(ignore_path, append=append)
 
-    log.message("Rewrote kash ignore file: %s", fmt_loc(ignore_path))
+    log.message("Rewritten kash ignore file: %s", fmt_loc(ignore_path))
 
 
 @kash_command

kash/exec/action_exec.py

@@ -1,7 +1,8 @@
 import time
 from dataclasses import replace
+from pathlib import Path
 
-from prettyfmt import fmt_lines, plural
+from prettyfmt import fmt_lines, fmt_path, plural
 
 from kash.config.logger import get_logger
 from kash.config.text_styles import (
@@ -32,7 +33,6 @@ from kash.utils.common.task_stack import task_stack
 from kash.utils.common.type_utils import not_none
 from kash.utils.errors import ContentError, InvalidOutput, get_nonfatal_exceptions
 from kash.workspaces import Selection, current_ws
-from kash.workspaces.workspace_importing import import_and_load
 
 log = get_logger(__name__)
 
@@ -49,7 +49,7 @@ def prepare_action_input(*input_args: CommandArg, refetch: bool = False) -> Acti
 
     # Ensure input items are already saved in the workspace and load the corresponding items.
     # This also imports any URLs.
-    input_items = [import_and_load(ws, arg) for arg in input_args]
+    input_items = [ws.import_and_load(arg) for arg in input_args]
 
     # URLs should have metadata like a title and be valid, so we fetch them.
     if input_items:
@@ -288,6 +288,14 @@ def save_action_result(
     Save the result of an action to the workspace. Handles skipping duplicates and
     archiving old inputs, if appropriate, based on hints in the ActionResult.
     """
+    # If an action returned an external path, we should confirm it exists or it is probably
+    # a bug in the action.
+    for item in result.items:
+        if item.external_path and not Path(item.external_path).exists():
+            raise InvalidOutput(
+                f"External path returned by action does not exist: {fmt_path(item.external_path)}"
+            )
+
     input_items = action_input.items
 
     skipped_paths = []
@@ -378,12 +386,16 @@ def run_action_with_caching(
         # Run it!
         result = run_action_operation(context, action_input, operation)
         result_store_paths, archived_store_paths = save_action_result(
-            ws, result, action_input, as_tmp=settings.tmp_output, no_format=settings.no_format
+            ws,
+            result,
+            action_input,
+            as_tmp=settings.tmp_output,
+            no_format=settings.no_format,
         )
 
         PrintHooks.before_done_message()
         log.message(
-            "%s Done: `%s` completed with %s %s",
+            "%s Action: `%s` completed with %s %s",
             EMOJI_SUCCESS,
             action.name,
             len(result.items),
@@ -449,13 +461,19 @@ def run_action_with_shell_context(
 
     # As a special case for convenience, if the action expects no args, ignore any pre-selected inputs.
     if action.expected_args == NO_ARGS and from_selection:
-        log.message("Not using current selection since action `%s` expects no args.", action_name)
+        log.message(
+            "Not using current selection since action `%s` expects no args.",
+            action_name,
+        )
         args.clear()
 
     if args:
         source_str = "provided args" if provided_args else "selection"
         log.message(
-            "Using %s as inputs to action `%s`:\n%s", source_str, action_name, fmt_lines(args)
+            "Using %s as inputs to action `%s`:\n%s",
+            source_str,
+            action_name,
+            fmt_lines(args),
         )
 
     # Get items for each input arg.

kash/exec/precondition_registry.py

@@ -16,11 +16,13 @@ def kash_precondition(func: Callable[[Item], bool]) -> Precondition:
     """
     Decorator to register a function as a Precondition.
     The function should return a bool and/or raise `PreconditionFailure`.
+    Returns an actual Precondition object, not the function, so that it's possible to
+    do precondition algebra, e.g. `is_file & has_body`.
 
     Example:
-        @register_precondition
-        def is_file(item: Item) -> bool:
-            return item.is_file()
+        @kash_precondition
+        def has_body(item: Item) -> bool:
+            return item.has_body()
     """
     precondition = Precondition(func)
 

kash/exec/preconditions.py

@@ -7,7 +7,7 @@ from chopdiff.html import has_timestamp
 
 from kash.exec.precondition_registry import kash_precondition
 from kash.model.items_model import Item, ItemType
-from kash.utils.file_utils.file_formats import is_full_html_page
+from kash.utils.file_utils.file_formats import is_fullpage_html
 from kash.utils.file_utils.file_formats_model import Format
 from kash.utils.text_handling.markdown_utils import extract_bullet_points
 
@@ -22,9 +22,14 @@ def is_doc_resource(item: Item) -> bool:
     return bool(is_resource(item) and item.format and item.format.is_doc)
 
 
+@kash_precondition
+def is_markdown_resource(item: Item) -> bool:
+    return bool(is_resource(item) and item.format and item.format.is_markdown)
+
+
 @kash_precondition
 def is_html_resource(item: Item) -> bool:
-    return bool(is_resource(item) and item.format and item.format == Format.html)
+    return bool(is_resource(item) and item.format and item.format.is_html)
 
 
 @kash_precondition
@@ -100,8 +105,23 @@ def has_html_body(item: Item) -> bool:
 
 
 @kash_precondition
-def has_full_html_page_body(item: Item) -> bool:
-    return bool(has_html_body(item) and item.body and is_full_html_page(item.body))
+def has_html_compatible_body(item: Item) -> bool:
+    return bool(has_body(item) and item.format and item.format.is_html_compatible)
+
+
+@kash_precondition
+def has_markdown_body(item: Item) -> bool:
+    return bool(has_body(item) and item.format and item.format.is_markdown)
+
+
+@kash_precondition
+def has_markdown_with_html_body(item: Item) -> bool:
+    return bool(has_body(item) and item.format and item.format.is_markdown_with_html)
+
+
+@kash_precondition
+def has_fullpage_html_body(item: Item) -> bool:
+    return bool(has_html_body(item) and item.body and is_fullpage_html(item.body))
 
 
 @kash_precondition
@@ -114,16 +134,21 @@ def is_markdown(item: Item) -> bool:
     return bool(has_body(item) and item.format and item.format.is_markdown)
 
 
+@kash_precondition
+def is_markdown_with_html(item: Item) -> bool:
+    return bool(has_body(item) and item.format and item.format.is_markdown_with_html)
+
+
 @kash_precondition
 def is_markdown_template(item: Item) -> bool:
-    return is_markdown(item) and contains_curly_vars(item)
+    return has_markdown_body(item) and contains_curly_vars(item)
 
 
 @kash_precondition
 def is_markdown_list(item: Item) -> bool:
     try:
         return (
-            is_markdown(item)
+            has_markdown_body(item)
             and item.body is not None
             and len(extract_bullet_points(item.body)) >= 2
         )

kash/exec/resolve_args.py

@@ -42,7 +42,7 @@ def resolve_path_arg(path_str: UnresolvedPath) -> Path | StorePath:
         return path
     else:
         try:
-            store_path = current_ws().resolve_path(path)
+            store_path = current_ws().resolve_to_store_path(path)
             if store_path:
                 return store_path
             else:
@@ -110,7 +110,7 @@ def resolvable_paths(paths: Sequence[StorePath | Path]) -> list[StorePath]:
     current workspace.
     """
     ws = current_ws()
-    resolvable = list(filter(None, (ws.resolve_path(p) for p in paths)))
+    resolvable = list(filter(None, (ws.resolve_to_store_path(p) for p in paths)))
     return resolvable
 
 

kash/file_storage/file_store.py

@@ -22,7 +22,7 @@ from kash.model.paths_model import StorePath
 from kash.shell.output.shell_output import PrintHooks
 from kash.utils.common.format_utils import fmt_loc
 from kash.utils.common.uniquifier import Uniquifier
-from kash.utils.common.url import Locator, Url, is_url
+from kash.utils.common.url import Locator, UnresolvedLocator, Url, is_url
 from kash.utils.errors import FileExists, FileNotFound, InvalidFilename, SkippableError
 from kash.utils.file_utils.file_formats_model import Format
 from kash.utils.file_utils.file_walk import walk_by_dir
@@ -182,7 +182,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 +195,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.
@@ -290,7 +305,7 @@ class FileStore(Workspace):
         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.warning(
+            log.info(
                 "Found existing item with same id:\n%s",
                 fmt_lines([fmt_loc(store_path), item_id]),
             )
@@ -334,6 +349,7 @@ class FileStore(Workspace):
         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.
@@ -342,6 +358,8 @@ class FileStore(Workspace):
         Unless `no_format` is true, also normalizes body text formatting (for Markdown)
         and updates the item's body to match.
 
+        If `no_frontmatter` is true, will not add frontmatter metadata to the item.
+
         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.
@@ -390,9 +408,14 @@ class FileStore(Workspace):
 
             # Now save the new item.
             try:
-                if item.external_path:
+                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.
+                if item.external_path and (no_frontmatter or not supports_frontmatter):
                     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",
@@ -448,7 +471,7 @@ class FileStore(Workspace):
 
     def import_item(
         self,
-        locator: Locator,
+        locator: UnresolvedLocator,
         *,
         as_type: ItemType | None = None,
         reimport: bool = False,
@@ -462,7 +485,10 @@ class FileStore(Workspace):
         """
         from kash.web_content.canon_url import canonicalize_url
 
-        if is_url(locator):
+        if isinstance(locator, StorePath) and not reimport:
+            log.info("Store path already imported: %s", fmt_loc(locator))
+            return locator
+        elif is_url(locator):
             # Import a URL as a resource.
             orig_url = Url(str(locator))
             url = canonicalize_url(orig_url)
@@ -480,9 +506,6 @@ class FileStore(Workspace):
             else:
                 store_path = self.save(item)
                 return store_path
-        elif isinstance(locator, StorePath) and not reimport:
-            log.info("Store path already imported: %s", fmt_loc(locator))
-            return locator
         else:
             # We have a path, possibly outside of or inside of the store.
             path = Path(locator).resolve()
@@ -553,6 +576,13 @@ class FileStore(Workspace):
             self.import_item(locator, as_type=as_type, reimport=reimport) for locator in locators
         ]
 
+    def import_and_load(self, locator: UnresolvedLocator) -> Item:
+        """
+        Import a locator and return the item.
+        """
+        store_path = self.import_item(locator)
+        return self.load(store_path)
+
     def _filter_selection_paths(self):
         """
         Filter out any paths that don't exist from all selections.
@@ -695,14 +725,20 @@ class FileStore(Workspace):
             dirs_ignored,
         )
 
-    def normalize(self, store_path: StorePath) -> StorePath:
+    def normalize(
+        self,
+        store_path: StorePath,
+        *,
+        no_format: bool = False,
+        no_frontmatter: bool = False,
+    ) -> StorePath:
         """
         Normalize an item or all items in a folder to make sure contents are in current
-        format.
+        format. This is the same as loading and saving the item.
         """
         log.info("Normalizing item: %s", fmt_path(store_path))
 
         item = self.load(store_path)
-        new_store_path = self.save(item)
+        new_store_path = self.save(item, no_format=no_format, no_frontmatter=no_frontmatter)
 
         return new_store_path