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

kash/model/items_model.py

@@ -6,7 +6,7 @@ from dataclasses import asdict, field, is_dataclass
 from datetime import UTC, datetime
 from enum import Enum
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, TypeVar
+from typing import TYPE_CHECKING, Any, NotRequired, TypedDict, TypeVar, Unpack
 
 from frontmatter_format import from_yaml_string, new_yaml
 from prettyfmt import (
@@ -25,6 +25,7 @@ from kash.model.media_model import MediaMetadata
 from kash.model.operations_model import OperationSummary, Source
 from kash.model.paths_model import StorePath, fmt_store_path
 from kash.text_handling.markdown_render import markdown_to_html
+from kash.text_handling.markdown_utils import first_heading
 from kash.utils.common.format_utils import fmt_loc, html_to_plaintext, plaintext_to_html
 from kash.utils.common.url import Locator, Url
 from kash.utils.errors import FileFormatError
@@ -32,7 +33,7 @@ from kash.utils.file_formats.chat_format import ChatHistory
 from kash.utils.file_utils.file_formats_model import FileExt, Format
 
 if TYPE_CHECKING:
-    from kash.model.actions_model import ExecContext
+    from kash.model.exec_model import ExecContext
     from kash.workspaces import Workspace
 
 log = get_logger(__name__)
@@ -120,6 +121,28 @@ class IdType(Enum):
     source = "source"
 
 
+class ItemUpdateOptions(TypedDict, total=False):
+    """
+    Keyword arguments that can be passed to update an Item.
+    """
+
+    type: NotRequired[ItemType]
+    state: NotRequired[State]
+    title: NotRequired[str | None]
+    url: NotRequired[Url | None]
+    description: NotRequired[str | None]
+    format: NotRequired[Format | None]
+    file_ext: NotRequired[FileExt | None]
+    body: NotRequired[str | None]
+    external_path: NotRequired[str | None]
+    original_filename: NotRequired[str | None]
+    relations: NotRequired[ItemRelations]
+    source: NotRequired[Source | None]
+    history: NotRequired[list[OperationSummary] | None]
+    thumbnail_url: NotRequired[Url | None]
+    extra: NotRequired[dict | None]
+
+
 @dataclass(frozen=True)
 class ItemId:
     """
@@ -257,9 +280,9 @@ class Item:
         """
         item_dict = {**item_dict, **kwargs}
 
-        info_prefix = (
-            f"{fmt_store_path(item_dict['store_path'])}: " if "store_path" in item_dict else ""
-        )
+        info_prefix = ""
+        if "store_path" in item_dict and item_dict["store_path"]:
+            info_prefix = f"{fmt_store_path(item_dict['store_path'])}: "
 
         # Metadata formats might change over time so it's important to gracefully handle issues.
         def set_field(key: str, default: Any, cls_: type[T]) -> T:
@@ -408,7 +431,7 @@ class Item:
         if self.type.expects_body and self.format.has_body and not self.body:
             raise ValueError(f"Item type `{self.type.value}` is text but has no body: {self}")
 
-    def absolute_path(self, ws: "Workspace | None" = None) -> Path:  # noqa: UP037
+    def absolute_path(self, ws: Workspace | None = None) -> Path:
         """
         Get the absolute path to the item. Throws `ValueError` if the item has no
         store path. If no workspace is provided, uses the current workspace.
@@ -496,38 +519,57 @@ class Item:
             display_title = self.abbrev_title()
         return display_title
 
-    def abbrev_title(self, max_len: int = 100, add_ops_suffix: bool = True) -> str:
+    def abbrev_title(
+        self,
+        *,
+        max_len: int = 100,
+        add_ops_suffix: bool = False,
+        pull_body_heading: bool = False,
+    ) -> str:
         """
         Get or infer a title for this item, falling back to the filename, URL,
         description, or finally body text.
         Optionally, include the last operation as a parenthetical at the end of the title.
         """
-        # Special case for URLs with no title..
+        from kash.file_storage.store_filenames import parse_item_filename
+
+        # First special case: if we are pulling the title from the body header, check
+        # that.
+        if not self.title and pull_body_heading:
+            heading = self.body_heading()
+            if heading:
+                return heading
+
+        # Next special case: URLs with no title use the url itself.
         if not self.title and self.url:
             return abbrev_str(self.url, max_len)
 
         # Special case for filenames with no title.
-        path_stem = (
-            (self.store_path and Path(self.store_path).stem)
-            or (self.external_path and Path(self.external_path).stem)
-            or (self.original_filename and Path(self.original_filename).stem)
-        )
-        if not self.title and path_stem:
-            return abbrev_str(path_stem, max_len)
+        # Use stem to drop suffix like .resource.docx etc in a title.
+        path = self.store_path or self.external_path or self.original_filename
+        if path:
+            path_name, _item_type, _format, _file_ext = parse_item_filename(Path(path).name)
+        else:
+            path_name = None
 
-        # Otherwise, use the title, description, or body text.
+        # Use the title or the path if possible, falling back to description or even body text.
         title_raw_text = (
             self.title
+            or path_name
             or self.description
             or (not self.is_binary and self.abbrev_body(max_len))
             or UNTITLED
         )
 
         suffix = ""
-        if add_ops_suffix and self.type not in [ItemType.concept, ItemType.resource]:
-            # For notes, exports, etc but not for concepts, add a parenthical note
-            # indicating the last operation, if there was one. This makes filename slugs
-            # more readable.
+        # For docs, etc but not for concepts/resources/exports, add a parenthical note
+        # indicating the last operation, if there was one. This makes filename slugs
+        # more readable.
+        if add_ops_suffix and self.type not in [
+            ItemType.concept,
+            ItemType.resource,
+            ItemType.export,
+        ]:
             last_op = self.history and self.history[-1].action_name
             if last_op:
                 step_num = len(self.history) + 1 if self.history else 1
@@ -544,9 +586,18 @@ class Item:
 
         return final_text
 
+    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 a cut off version of the body text. Must not be a binary Item.
+        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]
@@ -574,7 +625,7 @@ class Item:
         Get a readable slugified version of the title or filename or content
         appropriate for this item. May not be unique.
         """
-        title = self.abbrev_title(max_len=max_len)
+        title = self.abbrev_title(max_len=max_len, add_ops_suffix=True)
         slug = slugify_snake(title)
         return slug
 
@@ -613,13 +664,15 @@ class Item:
         """
         Get the full file extension suffix (e.g. "note.md") for this item.
         """
-
         if self.type == ItemType.extension:
             # Python files cannot have more than one . in them.
             return f"{FileExt.py.value}"
         elif self.type == ItemType.script:
             # Same for kash/xonsh scripts.
             return f"{self.type.value}.{FileExt.xsh.value}"
+        elif self.type == ItemType.export:
+            # For exports, skip the item type to keep it maximally compatible for external tools.
+            return f"{self.get_file_ext().value}"
         else:
             return f"{self.type.value}.{self.get_file_ext().value}"
 
@@ -632,11 +685,19 @@ class Item:
         return "\n\n".join(part for part in parts if part)
 
     def body_text(self) -> str:
+        """
+        Body text of the item, also validating that the item is not binary.
+        """
         if self.is_binary:
             raise ValueError("Cannot get text content of a binary Item")
         return self.body or ""
 
     def body_as_html(self) -> str:
+        """
+        Body of the item, converted to HTML format. Validates that the body format can be
+        converted and then converts plaintext or Markdown to HTML. Simply returns the body
+        if it is already HTML.
+        """
         if self.format == Format.html:
             return self.body_text()
         elif self.format == Format.plaintext:
@@ -647,7 +708,10 @@ class Item:
         raise ValueError(f"Cannot convert item of type {self.format} to HTML: {self}")
 
     def _copy_and_update(
-        self, other: Item | None = None, update_timestamp: bool = False, **other_updates
+        self,
+        other: Item | None = None,
+        update_timestamp: bool = False,
+        **other_updates: Unpack[ItemUpdateOptions],
     ) -> dict[str, Any]:
         overrides: dict[str, Any] = {"store_path": None, "modified_at": None}
         if update_timestamp:
@@ -665,10 +729,12 @@ class Item:
 
         return fields
 
-    def new_copy_with(self, update_timestamp: bool = True, **other_updates) -> Item:
+    def new_copy_with(
+        self, update_timestamp: bool = True, **other_updates: Unpack[ItemUpdateOptions]
+    ) -> Item:
         """
-        Copy item with the given field updates. Resets store_path to None. Updates
-        created time if requested.
+        Copy item with the given field updates. Resets `store_path` to None but preserves
+        other fields, including the body. Updates created time if requested.
         """
         new_fields = self._copy_and_update(update_timestamp=update_timestamp, **other_updates)
         return Item(**new_fields)
@@ -681,7 +747,7 @@ class Item:
         merged_fields = self._copy_and_update(other, update_timestamp=False)
         return Item(**merged_fields)
 
-    def derived_copy(self, type: ItemType, **other_updates) -> 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
@@ -691,7 +757,7 @@ class Item:
             if self.relations.derived_from:
                 log.message(
                     "Deriving from an item that has not been saved so using "
-                    "its derived_from relation: %s on %s",
+                    "upstream derived_from relation: %s on %s",
                     self.relations.derived_from,
                     self,
                 )
@@ -706,12 +772,12 @@ class Item:
         else:
             derived_from = [StorePath(self.store_path)]
 
-        updates = other_updates.copy()
-        updates["type"] = type
+        updates = updates.copy()
 
         # If format was specified and user didn't specify file_ext, then infer it.
-        if "file_ext" not in other_updates and "format" in other_updates:
-            updates["file_ext"] = other_updates["format"].file_ext
+        if "file_ext" not in updates and "format" in updates:
+            assert updates["format"] is not None
+            updates["file_ext"] = updates["format"].file_ext
 
         # External resource paths only make sense for resources, so clear them out if new item
         # is not a resource.
@@ -724,7 +790,7 @@ class Item:
             new_item.update_relations(derived_from=derived_from)
 
         # Fall back to action title template if we have it and title wasn't explicitly set.
-        if "title" not in other_updates:
+        if "title" not in updates:
             prev_title = self.title or (Path(self.store_path).stem if self.store_path else UNTITLED)
             if self.context:
                 action = self.context.action
@@ -764,7 +830,8 @@ class Item:
 
     def content_equals(self, other: Item) -> bool:
         """
-        Check if two items have identical content, ignoring timestamps and store path.
+        Check if two items have identical content, ignoring timestamps, store path,
+        and any trailing newlines or whitespace.
         """
         # Check relevant metadata fields.
         self_fields = self.__dict__.copy()

kash/model/operations_model.py

@@ -25,27 +25,46 @@ class OperationSummary:
 class Input:
     """
     An input to an operation, which may include a hash fingerprint.
+    Typically an input is a StorePath, but it could be something else like an in-memory
+    item that hasn't been saved yet.
     """
 
-    # TODO: May want to support Locators or other inputs besides StorePaths.
-    path: StorePath
+    path: StorePath | None
     hash: str | None = None
+    source_info: str | None = None
 
     @classmethod
     def parse(cls, input_str: str) -> Input:
         """
-        Parse an Input string in the format `some/path/filename.ext@sha1:hash` or
-        `@some/path/filename.ext@sha1:hash`, with a store path and a hash.
+        Parse an Input string in the format printed by `Input.parseable_str()`.
         """
-        parts = input_str.rsplit("@", 1)
-        if len(parts) == 2:
-            path, hash = parts
-            return cls(path=StorePath(path), hash=hash)
+        if input_str.startswith("[") and input_str.endswith("]"):
+            return cls(path=None, hash=None, source_info=input_str[1:-1])
         else:
-            return cls(path=StorePath(input_str), hash=None)
-
-    def path_and_hash(self):
-        return f"{fmt_loc(self.path)}@{self.hash}"
+            parts = input_str.rsplit("@", 1)
+            if len(parts) == 2:
+                path, hash = parts
+                return cls(path=StorePath(path), hash=hash)
+            else:
+                return cls(path=StorePath(input_str), hash=None)
+
+    def parseable_str(self):
+        """
+        A readable and parseable string describing the input, typically a hash and a path but
+        could be a path without a hash or another info in brackets. Paths may have an `@` at the
+        front.
+
+        some/path.txt@sha1:1234567890
+        @some/path.txt@sha1:1234567890
+        some/path.txt
+        [unsaved]
+        """
+        if self.path and self.hash:
+            return f"{fmt_loc(self.path)}@{self.hash}"
+        elif self.source_info:
+            return f"[{self.source_info}]"
+        else:
+            return "[input info missing]"
 
     # Inputs are equal if the hashes match (even if the paths have changed).
 
@@ -53,6 +72,10 @@ class Input:
         return hash(self.hash) if self.hash else object.__hash__(self)
 
     def __eq__(self, other: Any) -> bool:
+        """
+        Inputs are equal if the hashes match (even if the paths have changed) or if the paths
+        are the same. They are *not* equal otherwise, even if the source_info is the same.
+        """
         if not isinstance(other, Input):
             return NotImplemented
         if self.hash and other.hash:
@@ -62,7 +85,7 @@ class Input:
         return False
 
     def __str__(self):
-        return self.path_and_hash()
+        return self.parseable_str()
 
 
 @dataclass(frozen=True)
@@ -88,7 +111,7 @@ class Operation:
         }
 
         if self.arguments:
-            d["arguments"] = [arg.path_and_hash() for arg in self.arguments]
+            d["arguments"] = [arg.parseable_str() for arg in self.arguments]
         if self.options:
             d["options"] = self.options
 
@@ -101,7 +124,7 @@ class Operation:
         return [shell_quote(str(arg.path)) for arg in self.arguments]
 
     def hashed_args(self):
-        return [arg.path_and_hash() for arg in self.arguments]
+        return [arg.parseable_str() for arg in self.arguments]
 
     def quoted_options(self):
         return [f"--{k}={shell_quote(str(v))}" for k, v in self.options.items()]

kash/model/paths_model.py

@@ -264,6 +264,8 @@ def fmt_store_path(store_path: str | Path | StorePath) -> str:
     """
     Format a store path as a string.
     """
+    if not store_path:
+        raise ValueError("Cannot format empty store path")
     return StorePath(store_path).display_str()
 
 

kash/shell/output/shell_output.py

@@ -16,7 +16,7 @@ from rich.rule import Rule
 from rich.style import Style
 from rich.text import Text
 
-from kash.config.logger import get_console
+from kash.config.logger import get_console, is_console_quiet
 from kash.config.text_styles import (
     COLOR_HINT_DIM,
     COLOR_RESPONSE,
@@ -31,9 +31,6 @@ from kash.shell.output.kmarkdown import KMarkdown
 from kash.utils.rich_custom.rich_indent import Indent
 from kash.utils.rich_custom.rich_markdown_fork import Markdown
 
-console = get_console()
-
-
 print_context_var: contextvars.ContextVar[str] = contextvars.ContextVar("print_prefix", default="")
 """
 Context variable override for print prefix.
@@ -99,7 +96,12 @@ def rich_print(
     Print to the Rich console, either the global console or a thread-local
     override, if one is active. With `raw` true, we bypass rich formatting
     entirely and simply write to the console stream.
+
+    Output is suppressed by the global `console_quiet` setting.
     """
+    if is_console_quiet():
+        return
+
     console = get_console()
     if raw:
         # TODO: Indent not supported in raw mode.
@@ -136,7 +138,7 @@ def cprint(
     raw: bool = False,
 ):
     """
-    Main way to print to the shell. Wraps `rprint` with our additional
+    Main way to print to the shell. Wraps `rich_print` with our additional
     formatting options for text fill and prefix.
     """
     empty_indent = extra_indent.strip()
@@ -323,8 +325,8 @@ class PrintHooks(Enum):
     after_command_run = "after_command_run"
     before_status = "before_status"
     after_status = "after_status"
-    before_shell_action_run = "before_action_run"
-    after_shell_action_run = "after_action_run"
+    before_shell_action_run = "before_shell_action_run"
+    after_shell_action_run = "after_shell_action_run"
     before_log_action_run = "before_log_action_run"
     before_assistance = "before_assistance"
     after_assistance = "after_assistance"
@@ -376,7 +378,7 @@ class PrintHooks(Enum):
         elif self == PrintHooks.nonfatal_exception:
             self.nl()
         elif self == PrintHooks.before_done_message:
-            self.nl()
+            pass
         elif self == PrintHooks.before_output:
             self.nl()
         elif self == PrintHooks.after_output:

kash/shell/shell_main.py

@@ -14,10 +14,10 @@ import argparse
 import threading
 
 import xonsh.main
+from clideps.utils.readable_argparse import ReadableColorFormatter
 from strif import quote_if_needed
 
 from kash.config.setup import kash_setup
-from kash.shell.utils.argparse_utils import WrappedColorFormatter
 from kash.shell.version import get_full_version_name, get_version
 from kash.xonsh_custom.custom_shell import install_to_xonshrc, start_shell
 
@@ -51,7 +51,7 @@ def run_shell(single_command: str | None = None):
 
 
 def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(description=__doc__, formatter_class=WrappedColorFormatter)
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=ReadableColorFormatter)
 
     parser.add_argument("--version", action="version", version=get_full_version_name())
 

kash/shell/utils/exception_printing.py

@@ -5,7 +5,7 @@ from typing import TypeVar
 from kash.config.logger import get_logger
 from kash.config.text_styles import COLOR_ERROR
 from kash.shell.output.shell_output import PrintHooks
-from kash.utils.errors import NONFATAL_EXCEPTIONS
+from kash.utils.errors import get_nonfatal_exceptions
 
 log = get_logger(__name__)
 
@@ -41,7 +41,7 @@ def wrap_with_exception_printing(func: Callable[..., R]) -> Callable[[list[str]]
                 (", ".join(str(arg) for arg in args)),
             )
             return func(*args)
-        except NONFATAL_EXCEPTIONS as e:
+        except get_nonfatal_exceptions() as e:
             PrintHooks.nonfatal_exception()
             log.error(f"[{COLOR_ERROR}]Command error:[/{COLOR_ERROR}] %s", summarize_traceback(e))
             log.info("Command error details: %s", e, exc_info=True)

kash/shell/utils/shell_function_wrapper.py

@@ -27,7 +27,7 @@ def _map_positional(
     keywords_consumed = 0
 
     for param in pos_params:
-        param_type = param.type or str
+        param_type = param.effective_type or str
         if param.is_varargs:
             pos_values.extend([param_type(arg) for arg in pos_args[i:]])
             return pos_values, 0  # All remaining args are consumed, so we can return early.
@@ -39,7 +39,7 @@ def _map_positional(
 
     # If there are remaining positional arguments, they will go toward keyword arguments.
     for param in kw_params:
-        param_type = param.type or str
+        param_type = param.effective_type or str
         if not param.is_varargs and i < len(pos_args):
             pos_values.append(param_type(pos_args[i]))
             i += 1
@@ -70,30 +70,30 @@ def _map_keyword(kw_args: Mapping[str, str | bool], kw_params: list[FuncParam])
     for key, value in kw_args.items():
         matching_param = next((param for param in kw_params if param.name == key), None)
         if matching_param:
-            matching_param_type = matching_param.type or str
+            param_type = matching_param.effective_type or str
 
             # Handle UnionType (str | None) specially
-            if hasattr(types, "UnionType") and isinstance(matching_param_type, types.UnionType):
-                args = get_args(matching_param_type)
+            if hasattr(types, "UnionType") and isinstance(param_type, types.UnionType):
+                args = get_args(param_type)
                 non_none_args = [arg for arg in args if arg is not type(None)]
                 if len(non_none_args) == 1 and isinstance(non_none_args[0], type):
-                    matching_param_type = non_none_args[0]
+                    param_type = non_none_args[0]
 
-            if isinstance(value, bool) and not issubclass(matching_param_type, bool):
+            if isinstance(value, bool) and not issubclass(param_type, bool):
                 raise InvalidCommand(f"Option `--{key}` expects a value")
-            if not isinstance(value, bool) and issubclass(matching_param_type, bool):
+            if not isinstance(value, bool) and issubclass(param_type, bool):
                 raise InvalidCommand(f"Option `--{key}` is boolean and does not take a value")
 
             try:
-                kw_values[key] = instantiate_as_type(
-                    value, matching_param_type, accept_enum_names=True
-                )
+                kw_values[key] = instantiate_as_type(value, param_type, accept_enum_names=True)
             except Exception as e:
                 valid_values = ""
-                if isinstance(matching_param.type, type) and issubclass(matching_param.type, Enum):
-                    valid_values = f" (valid values are: {', '.join('`' + v.name + '`' for v in matching_param.type)})"
+                if isinstance(param_type, type) and issubclass(param_type, Enum):
+                    valid_values = (
+                        f" (valid values are: {', '.join('`' + v.name + '`' for v in param_type)})"
+                    )
                 raise InvalidCommand(
-                    f"Invalid value for parameter `{key}` of type {matching_param.type}: {value!r}{valid_values}"
+                    f"Invalid value for parameter `{key}` of type {param_type}: {value!r}{valid_values}"
                 ) from e
         elif var_kw_param:
             var_kw_values[key] = value
@@ -117,7 +117,7 @@ def wrap_for_shell_args(func: Callable[..., R]) -> Callable[[list[str]], R | Non
     from kash.commands.help import help_commands
 
     params = inspect_function_params(func)
-    pos_params = [p for p in params if p.is_positional]
+    pos_params = [p for p in params if p.is_pure_positional]
     kw_params = [p for p in params if p not in pos_params]
 
     @wraps(func)

kash/text_handling/doc_normalization.py

@@ -2,7 +2,7 @@ from pathlib import Path
 
 from flowmark import fill_markdown, fill_text, line_wrap_by_sentence
 from flowmark.text_filling import DEFAULT_WRAP_WIDTH
-from flowmark.text_wrapping import simple_word_splitter, wrap_paragraph
+from flowmark.text_wrapping import simple_word_splitter
 from frontmatter_format import fmf_read, fmf_write
 
 from kash.utils.common.format_utils import fmt_loc
@@ -11,20 +11,26 @@ 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 normalize_formatting_ansi(text: str, format: Format | None, width=DEFAULT_WRAP_WIDTH) -> str:
+def normalize_formatting(
+    text: str,
+    format: Format | None,
+    width=DEFAULT_WRAP_WIDTH,
+    support_ansi: bool = True,
+    cleanups: bool = True,
+) -> str:
     """
     Normalize text formatting by wrapping lines and normalizing Markdown.
+    This only does "safe" normalizations that cannot break the text.
     Enables ANSI support so ANSI codes and OSC-8 links are correctly handled.
     """
+    len_fn = ansi_cell_len if support_ansi else len
     if format == Format.plaintext:
-        return fill_text(
-            text, width=width, word_splitter=simple_word_splitter, len_fn=ansi_cell_len
-        )
+        return fill_text(text, width=width, word_splitter=simple_word_splitter, len_fn=len_fn)
     elif format == Format.markdown or format == Format.md_html:
         return fill_markdown(
             text,
-            line_wrapper=line_wrap_by_sentence(len_fn=ansi_cell_len),
-            cleanups=True,  # Safe cleanups like unbolding section headers.
+            line_wrapper=line_wrap_by_sentence(len_fn=len_fn, is_markdown=True),
+            cleanups=cleanups,
         )
     elif format == Format.html:
         # We don't currently auto-format HTML as we sometimes use HTML with specifically chosen line breaks.
@@ -37,6 +43,7 @@ def normalize_text_file(
     path: str | Path,
     target_path: Path,
     format: Format | None = None,
+    support_ansi: bool = True,
 ) -> None:
     """
     Normalize formatting on a text file, handling Markdown, HTML, or text, as well as
@@ -48,7 +55,7 @@ def normalize_text_file(
         raise ValueError(f"Cannot format non-text files: {fmt_loc(path)}")
 
     content, metadata = fmf_read(path)
-    norm_content = normalize_formatting_ansi(content, format=format)
+    norm_content = normalize_formatting(content, format=format, support_ansi=support_ansi)
     fmf_write(not_none(target_path), norm_content, metadata)
 
 
@@ -57,6 +64,7 @@ def normalize_text_file(
 
 def test_osc8_link():
     from clideps.terminal.osc_utils import osc8_link
+    from flowmark.text_wrapping import wrap_paragraph
 
     link = osc8_link("https://example.com/" + "x" * 50, "Example")
     assert ansi_cell_len(link) == 7

kash/text_handling/markdown_render.py

@@ -39,6 +39,7 @@ def html_postprocess(html: str) -> str:
     """
     Final tweaks to the HTML.
     """
+    # TODO: Improve rendering of footnote defs to put the up arrow next to the number instead?
     html = html.replace(
         """class="footnote">&#8617;</a>""", f"""class="footnote">{FOOTNOTE_UP_ARROW}</a>"""
     )