kash-shell 0.3.10__py3-none-any.whl → 0.3.12__py3-none-any.whl

kash/exec/action_exec.py

@@ -4,7 +4,12 @@ from dataclasses import replace
 from prettyfmt import fmt_lines
 
 from kash.config.logger import get_logger
-from kash.config.text_styles import EMOJI_SKIP, EMOJI_SUCCESS, EMOJI_TIMING
+from kash.config.text_styles import (
+    EMOJI_SKIP,
+    EMOJI_START,
+    EMOJI_SUCCESS,
+    EMOJI_TIMING,
+)
 from kash.exec.preconditions import is_url_item
 from kash.exec.resolve_args import assemble_action_args
 from kash.exec_model.args_model import CommandArg
@@ -17,15 +22,16 @@ from kash.model.actions_model import (
     ExecContext,
     PathOpType,
 )
+from kash.model.exec_model import RuntimeSettings
 from kash.model.items_model import Item, State
 from kash.model.operations_model import Input, Operation, Source
 from kash.model.params_model import ALL_COMMON_PARAMS, GLOBAL_PARAMS, RawParamValues
 from kash.model.paths_model import StorePath
-from kash.shell.output.shell_output import PrintHooks, print_h3
+from kash.shell.output.shell_output import PrintHooks
+from kash.utils.common.inflection import plural
 from kash.utils.common.task_stack import task_stack
 from kash.utils.common.type_utils import not_none
-from kash.utils.errors import NONFATAL_EXCEPTIONS, ContentError, InvalidOutput
-from kash.utils.lang_utils.inflection import plural
+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
 
@@ -63,6 +69,7 @@ def validate_action_input(
     """
     Validate an action input, ensuring the right number of args, all explicit params are filled,
     and the precondition holds and return an `Operation` that describes what will happen.
+    For flexibility, we don't require the items to be saved (have a store path).
     """
     input_items = action_input.items
     # Validations:
@@ -75,10 +82,16 @@ def validate_action_input(
 
     # Now make a note of the the operation we will perform.
     # If the inputs are paths, record the input paths, including hashes.
-    store_paths = [StorePath(not_none(item.store_path)) for item in input_items if item.store_path]
-    inputs = [Input(store_path, ws.hash(store_path)) for store_path in store_paths]
+    def input_for(item: Item) -> Input:
+        if item.store_path:
+            return Input(StorePath(item.store_path), ws.hash(StorePath(item.store_path)))
+        else:
+            return Input(path=None, source_info="unsaved")
+
+    inputs = [input_for(item) for item in input_items]
+
     # Add any non-default runtime options into the options summary.
-    options = {**action.param_value_summary(), **context.runtime_options}
+    options = {**action.param_value_summary(), **context.settings.non_default_options}
     operation = Operation(action.name, inputs, options)
 
     return operation
@@ -89,7 +102,7 @@ def log_action(action: Action, action_input: ActionInput, operation: Operation):
     Log the action and the operation we are about to run.
     """
     PrintHooks.before_log_action_run()
-    print_h3(f"Action `{action.name}`")
+    log.message("%s Action: `%s`", EMOJI_START, action.name)
     log.message("Running: `%s`", operation.command_line(with_options=True))
     if len(action.param_value_summary()) > 0:
         log.message("Parameters:\n%s", action.param_value_summary_str())
@@ -106,8 +119,9 @@ def check_for_existing_result(
     already exist.
     """
     action = context.action
-    ws = context.workspace
-    rerun = context.rerun
+    settings = context.settings
+    ws = settings.workspace
+    rerun = settings.rerun
 
     existing_result = None
 
@@ -154,6 +168,7 @@ def run_action_operation(
 
     # Run the action.
     action = context.action
+    settings = context.settings
     if action.run_per_item:
         result = _run_for_each_item(context, action_input)
     else:
@@ -172,9 +187,9 @@ def run_action_operation(
         item.update_history(Source(operation=this_op, output_num=i, cacheable=action.cacheable))
 
     # Override the state if appropriate (this handles marking items as transient).
-    if context.override_state:
+    if settings.override_state:
         for item in result.items:
-            item.state = context.override_state
+            item.state = settings.override_state
 
     log.info("Action `%s` result: %s", action.name, result)
 
@@ -233,7 +248,7 @@ def _run_for_each_item(context: ExecContext, input: ActionInput) -> ActionResult
                 log.info("Caught SkipItem exception, skipping run on this item")
                 result_items.append(item)
                 continue
-            except NONFATAL_EXCEPTIONS as e:
+            except get_nonfatal_exceptions() as e:
                 errors.append(e)
                 had_error = True
 
@@ -293,14 +308,18 @@ def save_action_result(
             fmt_lines(skipped_paths),
         )
 
-    input_store_paths = [StorePath(not_none(item.store_path)) for item in input_items]
+    unsaved_items = [item for item in input_items if not item.store_path]
+    input_store_paths = [StorePath(item.store_path) for item in input_items if item.store_path]
     result_store_paths = [StorePath(item.store_path) for item in result.items if item.store_path]
     old_inputs = sorted(set(input_store_paths) - set(result_store_paths))
+    if unsaved_items:
+        log.info("unsaved_items:\n%s", fmt_lines(unsaved_items))
     log.info("result_store_paths:\n%s", fmt_lines(result_store_paths))
-    log.info("old_inputs:\n%s", fmt_lines(old_inputs))
+    if old_inputs:
+        log.info("old_inputs:\n%s", fmt_lines(old_inputs))
 
     # If there is a hint that the action replaces the input, archive any inputs that are not in the result.
-    archived_store_paths = []
+    archived_store_paths: list[StorePath] = []
     if result.replaces_input and input_items:
         for input_store_path in old_inputs:
             # Note some outputs may be missing if replace_input was used.
@@ -325,7 +344,8 @@ def run_action_with_caching(
     Note: Mutates the input but only to add `context` to each item.
     """
     action = context.action
-    ws = context.workspace
+    settings = context.settings
+    ws = settings.workspace
 
     # For convenience, we include the context to each item too (this helps so per-item
     # functions don't have to take context args everywhere).
@@ -341,7 +361,7 @@ def run_action_with_caching(
     # Check if a previous run already produced the result.
     existing_result = check_for_existing_result(context, action_input, operation)
 
-    if existing_result and not context.rerun:
+    if existing_result and not settings.rerun:
         # Use the cached result.
         result = existing_result
         result_store_paths = [StorePath(not_none(item.store_path)) for item in result.items]
@@ -349,7 +369,7 @@ def run_action_with_caching(
 
         PrintHooks.before_done_message()
         log.message(
-            "%s Action skipped: `%s` completed with %s %s",
+            "%s Skipped: `%s` completed with %s %s",
             EMOJI_SKIP,
             action.name,
             len(result.items),
@@ -359,12 +379,12 @@ 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=context.tmp_output, no_format=context.no_format
+            ws, result, action_input, as_tmp=settings.tmp_output, no_format=settings.no_format
         )
 
         PrintHooks.before_done_message()
         log.message(
-            "%s Action done: `%s` completed with %s %s",
+            "%s Done: `%s` completed with %s %s",
             EMOJI_SUCCESS,
             action.name,
             len(result.items),
@@ -415,8 +435,7 @@ def run_action_with_shell_context(
     action_name = action.name
 
     # Execution context. This is fixed for the duration of the action.
-    context = ExecContext(
-        action=action,
+    settings = RuntimeSettings(
         workspace_dir=ws.base_dir,
         rerun=rerun,
         refetch=refetch,
@@ -424,6 +443,7 @@ def run_action_with_shell_context(
         tmp_output=tmp_output,
         no_format=no_format,
     )
+    context = ExecContext(action, settings)
 
     # Collect args from the provided args or otherwise the current selection.
     args, from_selection = assemble_action_args(*provided_args, use_selection=action.uses_selection)

kash/exec/llm_transforms.py

@@ -12,7 +12,8 @@ from kash.llm_utils.fuzzy_parsing import strip_markdown_fence
 from kash.llm_utils.llm_completion import llm_template_completion
 from kash.llm_utils.llm_messages import Message, MessageTemplate
 from kash.model.actions_model import LLMOptions
-from kash.model.items_model import Item, ItemType
+from kash.model.items_model import Item
+from kash.text_handling.doc_normalization import normalize_formatting
 from kash.utils.errors import InvalidInput
 from kash.utils.file_utils.file_formats_model import Format
 
@@ -90,6 +91,7 @@ def llm_transform_item(
     normalize: bool = True,
     strip_fence: bool = True,
     check_no_results: bool = True,
+    format: Format | None = None,
 ) -> Item:
     """
     Main function for running an LLM action on an item.
@@ -110,12 +112,13 @@ def llm_transform_item(
     log.message("LLM transform from action `%s` on item: %s", action.name, item)
     log.message("LLM options: %s", action.llm_options)
 
-    result_item = item.derived_copy(type=ItemType.doc, body=None, format=Format.markdown)
+    format = format or item.format or Format.markdown
+    result_item = item.derived_copy(body=None, format=format)
     result_str = llm_transform_str(llm_options, item.body, check_no_results=check_no_results)
     if strip_fence:
         result_str = strip_markdown_fence(result_str)
     if normalize:
-        result_str = fill_markdown(result_str)
+        result_str = normalize_formatting(result_str, format=format)
 
     result_item.body = result_str
     return result_item

kash/exec/preconditions.py

@@ -8,6 +8,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.text_handling.markdown_utils import extract_bullet_points
+from kash.utils.file_utils.file_formats import is_full_html_page
 from kash.utils.file_utils.file_formats_model import Format
 
 
@@ -84,13 +85,18 @@ def contains_curly_vars(item: Item) -> bool:
 
 
 @kash_precondition
-def has_text_body(item: Item) -> bool:
-    return has_body(item) and item.format in (Format.plaintext, Format.markdown, Format.md_html)
+def has_simple_text_body(item: Item) -> bool:
+    return bool(has_body(item) and item.format and item.format.is_simple_text)
 
 
 @kash_precondition
 def has_html_body(item: Item) -> bool:
-    return has_body(item) and item.format in (Format.html, Format.md_html)
+    return bool(has_body(item) and item.format and item.format.is_html)
+
+
+@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))
 
 
 @kash_precondition
@@ -100,7 +106,7 @@ def is_plaintext(item: Item) -> bool:
 
 @kash_precondition
 def is_markdown(item: Item) -> bool:
-    return has_body(item) and item.format in (Format.markdown, Format.md_html)
+    return bool(has_body(item) and item.format and item.format.is_markdown)
 
 
 @kash_precondition
@@ -113,14 +119,6 @@ def is_html(item: Item) -> bool:
     return has_body(item) and item.format == Format.html
 
 
-@kash_precondition
-def is_text_doc(item: Item) -> bool:
-    """
-    A document that can be processed by LLMs and other plaintext tools.
-    """
-    return (is_plaintext(item) or is_markdown(item)) and has_body(item)
-
-
 @kash_precondition
 def is_markdown_list(item: Item) -> bool:
     try:

kash/exec/resolve_args.py

@@ -105,6 +105,10 @@ def assemble_action_args(
 
 
 def resolvable_paths(paths: Sequence[StorePath | Path]) -> list[StorePath]:
+    """
+    Return which of the given StorePaths are resolvable (exist) in the
+    current workspace.
+    """
     ws = current_ws()
     resolvable = list(filter(None, (ws.resolve_path(p) for p in paths)))
     return resolvable

kash/exec/runtime_settings.py

@@ -0,0 +1,134 @@
+import contextvars
+from dataclasses import dataclass
+from pathlib import Path
+
+from kash.config.logger import get_logger
+from kash.model.exec_model import RuntimeSettings
+from kash.model.items_model import State
+from kash.workspaces.workspace_dirs import enclosing_ws_dir, global_ws_dir
+
+log = get_logger(__name__)
+
+_current_settings: contextvars.ContextVar[RuntimeSettings | None] = contextvars.ContextVar(
+    "current_runtime_settings", default=None
+)
+"""
+Context variable that tracks the current runtime settings. Only used if it is
+explicitly set with a `with runtime_settings(...):` block.
+"""
+
+
+def current_runtime_settings() -> RuntimeSettings:
+    """
+    Get the current runtime settings. Uses the ambient context var settings if
+    set and otherwise infers the workspace from the current working directory
+    with default runtime settings.
+    """
+
+    ambient_settings = _current_settings.get()
+    if ambient_settings:
+        return ambient_settings
+
+    default_ws_dir = enclosing_ws_dir() or global_ws_dir()
+    return RuntimeSettings(default_ws_dir)
+
+
+@dataclass(frozen=True)
+class WsContext:
+    global_ws_dir: Path
+    enclosing_ws_dir: Path | None
+    override_dir: Path | None
+
+    @property
+    def current_ws_dir(self) -> Path:
+        if self.override_dir:
+            return self.override_dir
+        elif self.enclosing_ws_dir:
+            return self.enclosing_ws_dir
+        else:
+            return self.global_ws_dir
+
+
+def current_ws_context() -> WsContext:
+    """
+    Context path info about the current workspace, including the global workspace
+    directory, any workspace directory that encloses the current working directory,
+    and override set via runtime settings.
+    """
+
+    override_dir = None
+    ambient_settings = _current_settings.get()
+    if ambient_settings:
+        override_dir = ambient_settings.workspace_dir
+
+    return WsContext(global_ws_dir(), enclosing_ws_dir(), override_dir)
+
+
+@dataclass
+class RuntimeSettingsManager:
+    """
+    Manage the context for executing actions, including `RuntimeSettings` and
+    `Workspace`.
+
+    This is a minimal base class for use as a context manager. Most functionality
+    is still in `FileStore`.
+
+    Workspaces may be detected based on the current working directory or explicitly
+    set using a `with` block:
+    ```
+    ws = get_ws("my_workspace")
+    with ws:
+        # code that calls current_ws() will use this workspace
+    ```
+    """
+
+    settings: RuntimeSettings
+
+    def __enter__(self):
+        self._token = _current_settings.set(self.settings)
+        log.info("New runtime context: %s", self.settings)
+        return self.settings
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        _current_settings.reset(self._token)
+        log.info("Exiting runtime context: %s", self.settings)
+
+
+def kash_runtime(
+    workspace_dir: Path | None,
+    *,
+    rerun: bool = False,
+    refetch: bool = False,
+    override_state: State | None = None,
+    tmp_output: bool = False,
+    no_format: bool = False,
+) -> RuntimeSettingsManager:
+    """
+    Set a specific kash execution context for a with block.
+    This allows defining a workspace and other execution settings as the ambient
+    context within the block.
+
+    If `workspace_dir` is not provided, the current workspace will be inferred
+    from the working directory or fall back to the global workspace.
+
+    Example usage:
+    ```
+    with kash_runtime(ws_path, rerun=args.rerun) as runtime:
+        runtime.workspace.log_workspace_info()
+        # Perform actions.
+    ```
+    """
+    from kash.workspaces.workspaces import current_ws
+
+    if workspace_dir is None:
+        workspace_dir = current_ws().base_dir
+
+    settings = RuntimeSettings(
+        workspace_dir=workspace_dir,
+        rerun=rerun,
+        refetch=refetch,
+        override_state=override_state,
+        tmp_output=tmp_output,
+        no_format=no_format,
+    )
+    return RuntimeSettingsManager(settings=settings)

kash/exec/shell_callable_action.py

@@ -13,7 +13,7 @@ from kash.model.params_model import RawParamValues
 from kash.shell.output.shell_output import PrintHooks
 from kash.shell.utils.exception_printing import summarize_traceback
 from kash.utils.common.parse_shell_args import parse_shell_args
-from kash.utils.errors import NONFATAL_EXCEPTIONS
+from kash.utils.errors import get_nonfatal_exceptions
 
 log = get_logger(__name__)
 
@@ -71,14 +71,16 @@ class ShellCallableAction:
                     action_cls, explicit_values, *shell_args.args, rerun=rerun, refetch=refetch
                 )
             # We don't return the result to keep the xonsh shell output clean.
-        except NONFATAL_EXCEPTIONS as e:
+        except get_nonfatal_exceptions() as e:
             PrintHooks.nonfatal_exception()
             log.error(f"[{COLOR_ERROR}]Action error:[/{COLOR_ERROR}] %s", summarize_traceback(e))
             log.info("Action error details: %s", e, exc_info=True)
             return ShellResult(exception=e)
         except Exception as e:
             # Log here while we are in the true call stack (not inside the xonsh call stack).
-            log.error("Action error: %s", e, exc_info=KashEnv.KASH_SHOW_TRACEBACK.read_bool(True))
+            log.error(
+                "Action error: %s", e, exc_info=KashEnv.KASH_SHOW_TRACEBACK.read_bool(default=True)
+            )
             raise
         finally:
             log_tallies(level="warning", if_slower_than=10.0)

kash/file_storage/file_store.py

@@ -5,7 +5,7 @@ import time
 from collections.abc import Callable, Generator
 from os.path import join, relpath
 from pathlib import Path
-from typing import Any, TypeVar
+from typing import Concatenate, ParamSpec, TypeVar
 
 from funlog import format_duration, log_calls
 from prettyfmt import fmt_lines, fmt_path
@@ -13,13 +13,13 @@ from strif import copyfile_atomic, hash_file, move_file
 from typing_extensions import override
 
 from kash.config.logger import get_log_settings, get_logger
-from kash.config.text_styles import EMOJI_SAVED, STYLE_HINT
+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.model.items_model import Item, ItemId, ItemType
 from kash.model.paths_model import StorePath
-from kash.shell.output.shell_output import PrintHooks, cprint
+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
@@ -34,16 +34,18 @@ from kash.workspaces.workspaces import Workspace
 log = get_logger(__name__)
 
 
+SelfT = TypeVar("SelfT")
 T = TypeVar("T")
+P = ParamSpec("P")
 
 
-def synchronized(method: Callable[..., T]) -> Callable[..., T]:
+def synchronized(method: Callable[Concatenate[SelfT, P], T]) -> Callable[Concatenate[SelfT, P], T]:
     """
     Simple way to synchronize a few methods.
     """
 
     @functools.wraps(method)
-    def synchronized_method(self, *args: Any, **kwargs: Any) -> T:
+    def synchronized_method(self, *args: P.args, **kwargs: P.kwargs) -> T:
         with self._lock:
             return method(self, *args, **kwargs)
 
@@ -316,9 +318,11 @@ class FileStore(Workspace):
         Save the item. Uses the `store_path` if it's already set or generates a new one.
         Updates `item.store_path`.
 
+        Unless `no_format` is true, also normalizes body text formatting (for Markdown)
+        and updates the item's body to match.
+
         If `as_tmp` is true, will save the item to a temporary file.
         If `overwrite` is false, will skip saving if the item already exists.
-        If `no_format` is true, will not normalize body text formatting (for Markdown).
         """
         # If external file already exists within the workspace, the file is already saved (without metadata).
         external_path = item.external_path and Path(item.external_path).resolve()
@@ -450,19 +454,11 @@ class FileStore(Workspace):
             if not path.exists():
                 raise FileNotFound(f"File not found: {fmt_loc(path)}")
 
-            # It's a path outside the store, so copy it in.
-            _name, filename_item_type, format, _file_ext = parse_item_filename(path)
-
-            # Best guesses on item types if not specified.
-            item_type = as_type
-            if not item_type and filename_item_type:
-                item_type = filename_item_type
-            if not item_type and format:
-                item_type = ItemType.for_format(format)
-            if not item_type:
-                item_type = ItemType.resource
+            # First treat it as an external file to analyze file type and format.
+            item = Item.from_external_path(path)
 
-            if format and format.supports_frontmatter:
+            # If it's a text/frontmatter-friendly, read it fully.
+            if item.format and item.format.supports_frontmatter:
                 log.message("Importing text file: %s", fmt_loc(path))
                 # This will read the file with or without frontmatter.
                 # We are importing so we want to drop the external path so we save the body.
@@ -483,18 +479,27 @@ class FileStore(Workspace):
                 store_path = self.save(item)
                 log.info("Imported text file: %s", item.as_str())
             else:
-                log.message("Importing non-text file: %s", fmt_loc(path))
                 # Binary or other files we just copy over as-is, preserving the name.
                 # We know the extension is recognized.
-                item = Item.from_external_path(path)
-                store_path, _found, _prev = self.store_path_for(item)
+                store_path, _found, old_store_path = self.store_path_for(item)
                 if self.exists(store_path):
                     raise FileExists(f"Resource already in store: {fmt_loc(store_path)}")
 
-                item.type = item_type
-
-                log.message("Importing resource: %s -> %s", fmt_loc(path), fmt_loc(store_path))
+                log.message("Importing resource: %s", fmt_loc(path))
                 copyfile_atomic(path, self.base_dir / store_path, make_parents=True)
+
+                # Optimization: Don't import an identical file twice.
+                if old_store_path:
+                    old_hash = self.hash(old_store_path)
+                    new_hash = self.hash(store_path)
+                    if old_hash == new_hash:
+                        log.message(
+                            "Imported resource is identical to the previous import: %s",
+                            fmt_loc(old_store_path),
+                        )
+                        os.unlink(self.base_dir / store_path)
+                        store_path = old_store_path
+                log.message("Imported resource: %s", fmt_loc(store_path))
             return store_path
 
     def import_items(
@@ -584,12 +589,13 @@ class FileStore(Workspace):
         move_file(full_input_path, original_path)
         return StorePath(store_path)
 
-    def log_workspace_info(self, *, once: bool = False):
+    @synchronized
+    def log_workspace_info(self, *, once: bool = False) -> bool:
         """
         Log helpful information about the workspace.
         """
         if once and self.info_logged:
-            return
+            return False
 
         self.info_logged = True
 
@@ -604,25 +610,18 @@ class FileStore(Workspace):
             fmt_path(get_log_settings().log_file_path.absolute(), rel_to_cwd=False),
         )
         log.message(
-            "Media cache: %s", fmt_path(self.base_dir / self.dirs.media_cache_dir, rel_to_cwd=False)
-        )
-        log.message(
-            "Content cache: %s",
+            "Caches: %s, %s",
+            fmt_path(self.base_dir / self.dirs.media_cache_dir, rel_to_cwd=False),
             fmt_path(self.base_dir / self.dirs.content_cache_dir, rel_to_cwd=False),
         )
+        log.message("Current working directory: %s", fmt_path(Path.cwd(), rel_to_cwd=False))
+
         for warning in self.warnings:
             log.warning("%s", warning)
 
-        if self.is_global_ws:
-            PrintHooks.spacer()
-            log.warning("Note you are currently using the default global workspace.")
-            cprint(
-                "Create or switch to another workspace with the `workspace` command.",
-                style=STYLE_HINT,
-            )
-
         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
 
     def walk_items(
         self,

kash/file_storage/item_file_format.py

@@ -7,7 +7,7 @@ from prettyfmt import custom_key_sort, fmt_size_human
 from kash.config.logger import get_logger
 from kash.model.items_model import ITEM_FIELDS, Item
 from kash.model.operations_model import OPERATION_FIELDS
-from kash.text_handling.doc_normalization import normalize_formatting_ansi
+from kash.text_handling.doc_normalization import normalize_formatting
 from kash.utils.common.format_utils import fmt_loc
 from kash.utils.file_utils.file_formats_model import Format
 from kash.utils.file_utils.mtime_cache import MtimeCache
@@ -25,7 +25,7 @@ _item_cache = MtimeCache[Item](max_size=2000, name="Item")
 def write_item(item: Item, path: Path, normalize: bool = True):
     """
     Write a text item to a file with standard frontmatter format YAML.
-    Also normalizes formatting of the body text.
+    By default normalizes formatting of the body text and updates the item's body.
     """
     item.validate()
     if item.is_binary:
@@ -37,7 +37,7 @@ def write_item(item: Item, path: Path, normalize: bool = True):
     _item_cache.delete(path)
 
     if normalize:
-        body = normalize_formatting_ansi(item.body_text(), item.format)
+        body = normalize_formatting(item.body_text(), item.format)
     else:
         body = item.body_text()
 
@@ -79,6 +79,9 @@ def write_item(item: Item, path: Path, normalize: bool = True):
     # Update cache.
     _item_cache.update(path, item)
 
+    # Update the item's body to reflect normalization.
+    item.body = body
+
 
 def read_item(path: Path, base_dir: Path | None) -> Item:
     """

kash/file_storage/store_filenames.py

@@ -1,15 +1,18 @@
+from functools import cache
 from pathlib import Path
 
 from kash.config.logger import get_logger
 from kash.model.items_model import ItemType
+from kash.utils.common.inflection import plural
 from kash.utils.file_utils.file_formats_model import FileExt, Format
 from kash.utils.file_utils.filename_parsing import split_filename
-from kash.utils.lang_utils.inflection import plural
 
 log = get_logger(__name__)
 
 
-_type_to_folder = {name: plural(name) for name, _value in ItemType.__members__.items()}
+@cache
+def _get_type_to_folder() -> dict[str, str]:
+    return {name: plural(name) for name, _value in ItemType.__members__.items()}
 
 
 def folder_for_type(item_type: ItemType) -> Path:
@@ -22,7 +25,7 @@ def folder_for_type(item_type: ItemType) -> Path:
     export -> exports
     etc.
     """
-    return Path(_type_to_folder[item_type.name])
+    return Path(_get_type_to_folder()[item_type.name])
 
 
 def join_suffix(base_slug: str, full_suffix: str) -> str: