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

kash/actions/core/markdownify.py

@@ -1,8 +1,10 @@
 from kash.config.logger import get_logger
 from kash.exec import kash_action
-from kash.exec.preconditions import has_html_body, is_url_item
+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
 
@@ -10,21 +12,23 @@ log = get_logger(__name__)
 
 
 @kash_action(
-    precondition=is_url_item | has_html_body,
-    params=common_params("refetch"),
+    precondition=is_url_resource | has_html_body,
     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.
     """
-    from markdownify import markdownify as markdownify_convert
 
+    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)
-    markdown_content = markdownify_convert(page_data.clean_html)
+    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_item
+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
 
@@ -10,18 +10,19 @@ log = get_logger(__name__)
 
 
 @kash_action(
-    precondition=is_url_item | has_html_body,
-    params=common_params("refetch"),
+    precondition=is_url_resource | has_html_body,
     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
-    url, html_content = get_url_html(item, expiration_sec=expiration_sec)
-    page_data = extract_text_readabilipy(url, html_content)
+    locator, html_content = get_url_html(item, expiration_sec=expiration_sec)
+    page_data = extract_text_readabilipy(locator, html_content)
 
     output_item = item.derived_copy(format=Format.html, body=page_data.clean_html)
 

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,10 +11,10 @@ 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,
-    params=(Param("add_title", "Add a title to the page body.", type=bool),),
+    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, add_title: bool = False) -> ActionResult:
+def render_as_html(input: ActionInput, no_title: bool = False) -> ActionResult:
     """
     Convert text, Markdown, or HTML to pretty, formatted HTML using a clean
     and simple page template. Supports GFM-flavored Markdown tables and footnotes.
@@ -27,11 +27,13 @@ def render_as_html(input: ActionInput, add_title: bool = False) -> ActionResult:
     """
     if len(input.items) == 1:
         input_item = input.items[0]
-        html_body = simple_webpage_render(input_item, add_title_h1=add_title)
+        html_body = simple_webpage_render(input_item, add_title_h1=not no_title)
         result_item = input_item.derived_copy(
             type=ItemType.export, format=Format.html, body=html_body
         )
         return ActionResult([result_item])
     else:
         config_result = tabbed_webpage_config(input)
-        return tabbed_webpage_generate(ActionInput(items=config_result.items), add_title=add_title)
+        return tabbed_webpage_generate(
+            ActionInput(items=config_result.items), add_title=not no_title
+        )

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/base/basic_file_commands.py

@@ -81,6 +81,9 @@ def clipboard_paste(path: str = "untitled_paste.txt") -> None:
     import pyperclip
 
     contents = pyperclip.paste()
+    if not contents.strip():
+        raise InvalidInput("Clipboard is empty")
+
     with atomic_output_file(path, backup_suffix=".{timestamp}.bak") as f:
         f.write_text(contents)
 

kash/commands/base/diff_commands.py

@@ -5,16 +5,51 @@ from kash.commands.workspace.selection_commands import select
 from kash.config.logger import get_logger
 from kash.exec import import_locator_args, kash_command
 from kash.exec_model.shell_model import ShellResult
-from kash.model.items_model import Item, ItemType
+from kash.model.items_model import Item, ItemRelations, ItemType
+from kash.model.paths_model import StorePath
 from kash.shell.output.shell_output import Wrap, cprint
-from kash.text_handling.unified_diffs import unified_diff_files, unified_diff_items
-from kash.utils.errors import InvalidInput, InvalidOperation
+from kash.utils.errors import ContentError, InvalidInput, InvalidOperation
 from kash.utils.file_utils.file_formats_model import Format
+from kash.utils.text_handling.unified_diffs import unified_diff, unified_diff_files
 from kash.workspaces import current_ws
 
 log = get_logger(__name__)
 
 
+def unified_diff_items(from_item: Item, to_item: Item, strict: bool = True) -> Item:
+    """
+    Generate a unified diff between two items. If `strict` is true, will raise
+    an error if the items are of different formats.
+    """
+    if not from_item.body and not to_item.body:
+        raise ContentError(f"No body to diff for {from_item} and {to_item}")
+    if not from_item.store_path or not to_item.store_path:
+        raise ContentError("No store path on items; save before diffing")
+    diff_items = [item for item in [from_item, to_item] if item.format == Format.diff]
+    if len(diff_items) == 1:
+        raise ContentError(
+            f"Cannot compare diffs to non-diffs: {from_item.format}, {to_item.format}"
+        )
+    if len(diff_items) > 0 or from_item.format != to_item.format:
+        msg = f"Diffing items of incompatible format: {from_item.format}, {to_item.format}"
+        if strict:
+            raise ContentError(msg)
+        else:
+            log.warning("%s", msg)
+
+    from_path, to_path = StorePath(from_item.store_path), StorePath(to_item.store_path)
+
+    diff = unified_diff(from_item.body, to_item.body, str(from_path), str(to_path))
+
+    return Item(
+        type=ItemType.doc,
+        title=f"Diff of {from_path} and {to_path}",
+        format=Format.diff,
+        relations=ItemRelations(diff_of=[from_path, to_path]),
+        body=diff.patch_text,
+    )
+
+
 @kash_command
 def diff_items(*paths: str, force: bool = False) -> ShellResult:
     """

kash/commands/base/reformat_command.py

@@ -8,9 +8,9 @@ from kash.config.logger import get_logger
 from kash.exec import assemble_path_args, kash_command, resolvable_paths
 from kash.exec_model.shell_model import ShellResult
 from kash.shell.output.shell_output import print_status
-from kash.text_handling.doc_normalization import normalize_text_file
 from kash.utils.common.format_utils import fmt_loc
 from kash.utils.file_utils.filename_parsing import join_filename, split_filename
+from kash.utils.text_handling.doc_normalization import normalize_text_file
 
 log = get_logger(__name__)
 

kash/commands/base/show_command.py

@@ -54,7 +54,7 @@ def show(
                 item = ws.load(input_path)
                 if thumbnail and item.thumbnail_url:
                     try:
-                        local_path, _was_cached = cache_file(item.thumbnail_url)
+                        local_path = cache_file(item.thumbnail_url).content.path
                         terminal_show_image(local_path)
                     except Exception as e:
                         log.info("Had trouble showing thumbnail image (will skip): %s", e)

kash/commands/workspace/selection_commands.py

@@ -2,6 +2,7 @@ from os.path import basename
 from pathlib import Path
 
 from frontmatter_format import fmf_strip_frontmatter
+from prettyfmt import plural
 from strif import copyfile_atomic
 
 from kash.config.logger import get_logger
@@ -10,7 +11,6 @@ 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
 from kash.utils.common.format_utils import fmt_loc
-from kash.utils.common.inflection import plural
 from kash.utils.errors import InvalidInput
 from kash.workspaces import Selection, current_ws
 

kash/commands/workspace/workspace_commands.py

@@ -2,7 +2,7 @@ import os
 from pathlib import Path
 
 from frontmatter_format import to_yaml_string
-from prettyfmt import fmt_lines
+from prettyfmt import fmt_lines, plural
 from rich.text import Text
 
 from kash.commands.base.basic_file_commands import trash
@@ -26,7 +26,7 @@ from kash.exec.action_registry import get_all_actions_defaults
 from kash.exec.fetch_url_metadata import fetch_url_metadata
 from kash.exec.precondition_checks import actions_matching_paths
 from kash.exec.precondition_registry import get_all_preconditions
-from kash.exec.preconditions import is_url_item
+from kash.exec.preconditions import is_url_resource
 from kash.exec_model.shell_model import ShellResult
 from kash.local_server.local_url_formatters import local_url_formatter
 from kash.media_base import media_tools
@@ -51,14 +51,14 @@ from kash.shell.output.shell_output import (
 )
 from kash.shell.utils.native_utils import tail_file
 from kash.utils.common.format_utils import fmt_loc
-from kash.utils.common.inflection import plural
 from kash.utils.common.obj_replace import remove_values
 from kash.utils.common.parse_key_vals import parse_key_value
 from kash.utils.common.type_utils import not_none
-from kash.utils.common.url import Url, is_url
+from kash.utils.common.url import Url, is_url, parse_http_url
 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.web_content.file_cache_utils import cache_file
 from kash.workspaces import (
     current_ws,
@@ -181,48 +181,85 @@ def cache_content(*urls_or_paths: str, refetch: bool = False) -> None:
     PrintHooks.spacer()
     for url_or_path in urls_or_paths:
         locator = resolve_locator_arg(url_or_path)
-        cache_path, was_cached = cache_file(locator, expiration_sec=expiration_sec)
-        cache_str = " (already cached)" if was_cached else ""
+        cache_result = cache_file(locator, expiration_sec=expiration_sec)
+        cache_str = " (already cached)" if cache_result.was_cached else ""
         cprint(f"{fmt_loc(url_or_path)}{cache_str}:", style=STYLE_EMPH, text_wrap=Wrap.NONE)
-        cprint(f"{cache_path}", text_wrap=Wrap.INDENT_ONLY)
+        cprint(f"{cache_result.content.path}", text_wrap=Wrap.INDENT_ONLY)
         PrintHooks.spacer()
 
 
 @kash_command
-def download(*urls_or_paths: str, refetch: bool = False) -> None:
+def download(*urls_or_paths: str, refetch: 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.
+    Creates both resource and document versions for text content.
     """
-    expiration_sec = 0 if refetch else None
-
-    # TODO: Add option to include frontmatter metadata for text files.
     ws = current_ws()
+    saved_paths = []
+
     for url_or_path in urls_or_paths:
         locator = resolve_locator_arg(url_or_path)
-        url = None
+        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_item(url_item):
+            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):
-            store_path = ws.import_item(locator, as_type=ItemType.resource)
             log.message(
-                "URL is a media URL, so added as a resource and will cache media: %s", fmt_loc(url)
+                "URL is a media URL, so adding as a resource and will cache media: %s", fmt_loc(url)
             )
+            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))
-            cache_path, _was_cached = cache_file(url, expiration_sec=expiration_sec)
-            item = Item.from_external_path(cache_path, item_type=ItemType.resource)
-            store_path = ws.save(item)
+            # Cache the content first
+            expiration_sec = 0 if refetch else None
+            cache_result = cache_file(url, expiration_sec=expiration_sec)
+            original_filename = Path(parse_http_url(url).path).name
+            mime_type = cache_result.content.headers and cache_result.content.headers.mime_type
+
+            # 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(resource_item, no_frontmatter=True, no_format=True)
+            saved_paths.append(store_path)
+
+            # Also create a doc version for text content
+            if resource_item.format and resource_item.format.supports_frontmatter:
+                doc_item = Item.from_external_path(
+                    cache_result.content.path,
+                    ItemType.doc,
+                    url=url,
+                    mime_type=mime_type,
+                    original_filename=original_filename,
+                )
+                doc_store_path = ws.save(doc_item, no_frontmatter=False, no_format=False)
+                saved_paths.append(doc_store_path)
 
-        log.info("Saved item to workspace: %s", fmt_loc(store_path))
+    print_status(
+        "Downloaded %s %s:\n%s",
+        len(saved_paths),
+        plural("item", len(saved_paths)),
+        fmt_lines(saved_paths),
+    )
+    select(*saved_paths)
+
+    return ShellResult(show_selection=True)
 
 
 @kash_command
@@ -437,7 +474,7 @@ def import_item(
     *files_or_urls: str, type: ItemType | None = None, inplace: bool = False
 ) -> ShellResult:
     """
-    Add a file or URL resource to the workspace as an item, with associated metadata.
+    Add a file or URL resource to the workspace as an item.
 
     :param inplace: If set and the item is already in the store, reimport the item,
       adding or rewriting metadata frontmatter.
@@ -464,6 +501,34 @@ def import_item(
     return ShellResult(show_selection=True)
 
 
+@kash_command
+def save_clipboard(
+    title: str | None = "pasted_text",
+    type: ItemType = ItemType.resource,
+    format: Format = Format.plaintext,
+) -> ShellResult:
+    """
+    Import the contents of the OS-native clipboard as a new item in the workspace.
+
+    :param title: The title of the new item (default: "pasted_text").
+    :param type: The type of the new item (default: resource).
+    :param format: The format of the new item (default: plaintext).
+    """
+    import pyperclip
+
+    contents = pyperclip.paste()
+    if not contents.strip():
+        raise InvalidInput("Clipboard is empty")
+
+    ws = current_ws()
+    store_path = ws.save(Item(type=type, format=format, title=title, body=contents))
+
+    print_status("Imported clipboard contents to:\n%s", fmt_lines([fmt_loc(store_path)]))
+    select(store_path)
+
+    return ShellResult(show_selection=True)
+
+
 @kash_command
 def fetch_metadata(*files_or_urls: str, refetch: bool = False) -> ShellResult:
     """
@@ -472,8 +537,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()
@@ -483,12 +546,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)
@@ -670,7 +733,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/docs/load_source_code.py

@@ -104,7 +104,7 @@ def load_source_code() -> SourceCode:
             kash_base_path / "model" / "assistant_response_model.py",
         ),
         text_tool_src=read_source_code(
-            kash_base_path / "text_handling",
+            kash_base_path / "utils" / "text_handling",
             kash_base_path / "utils" / "lang_utils",
             # TODO: Include additional dep libs like chopdiff TextDoc too?
         ),

kash/exec/action_exec.py

@@ -1,7 +1,7 @@
 import time
 from dataclasses import replace
 
-from prettyfmt import fmt_lines
+from prettyfmt import fmt_lines, plural
 
 from kash.config.logger import get_logger
 from kash.config.text_styles import (
@@ -10,7 +10,7 @@ from kash.config.text_styles import (
     EMOJI_SUCCESS,
     EMOJI_TIMING,
 )
-from kash.exec.preconditions import is_url_item
+from kash.exec.preconditions import is_url_resource
 from kash.exec.resolve_args import assemble_action_args
 from kash.exec_model.args_model import CommandArg
 from kash.file_storage.file_store import FileStore
@@ -28,12 +28,10 @@ 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
-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 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__)
 
@@ -50,13 +48,13 @@ 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:
         log.message("Assembling metadata for input items:\n%s", fmt_lines(input_items))
         input_items = [
-            fetch_url_item_metadata(item, refetch=refetch) if is_url_item(item) else item
+            fetch_url_item_metadata(item, refetch=refetch) if is_url_resource(item) else item
             for item in input_items
         ]
 
@@ -299,7 +297,7 @@ def save_action_result(
                 skipped_paths.append(store_path)
                 continue
 
-        ws.save(item, as_tmp=as_tmp, no_format=no_format)
+        ws.save(item, overwrite=result.overwrite, as_tmp=as_tmp, no_format=no_format)
 
     if skipped_paths:
         log.message(
@@ -384,7 +382,7 @@ def run_action_with_caching(
 
         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),

kash/exec/fetch_url_metadata.py

@@ -1,19 +1,18 @@
 from kash.config.logger import get_logger
-from kash.exec.preconditions import is_url_item
+from kash.exec.preconditions import is_url_resource
 from kash.media_base.media_services import get_media_metadata
 from kash.model.items_model import Item, ItemType
 from kash.model.paths_model import StorePath
 from kash.utils.common.format_utils import fmt_loc
 from kash.utils.common.url import Url, is_url
 from kash.utils.errors import InvalidInput
-from kash.web_content.canon_url import canonicalize_url
-from kash.web_content.web_extract import fetch_extract
-from kash.workspaces import current_ws
 
 log = get_logger(__name__)
 
 
 def fetch_url_metadata(locator: Url | StorePath, refetch: bool = False) -> Item:
+    from kash.workspaces import current_ws
+
     ws = current_ws()
     if is_url(locator):
         # Import or find URL as a resource in the current workspace.
@@ -21,7 +20,7 @@ def fetch_url_metadata(locator: Url | StorePath, refetch: bool = False) -> Item:
         item = ws.load(store_path)
     elif isinstance(locator, StorePath):
         item = ws.load(locator)
-        if not is_url_item(item):
+        if not is_url_resource(item):
             raise InvalidInput(f"Not a URL resource: {fmt_loc(locator)}")
     else:
         raise InvalidInput(f"Not a URL or URL resource: {fmt_loc(locator)}")
@@ -34,6 +33,10 @@ def fetch_url_item_metadata(item: Item, refetch: bool = False) -> Item:
     Fetch metadata for a URL using a media service if we recognize the URL,
     and otherwise fetching and extracting it from the web page HTML.
     """
+    from kash.web_content.canon_url import canonicalize_url
+    from kash.web_content.web_extract import fetch_extract
+    from kash.workspaces import current_ws
+
     ws = current_ws()
     if not refetch and item.title and item.description:
         log.message(

kash/exec/importing.py

@@ -5,7 +5,7 @@ from prettyfmt import fmt_lines, fmt_path
 from kash.config.logger import get_logger
 from kash.exec.action_registry import action_classes, refresh_action_classes
 from kash.exec.command_registry import get_all_commands
-from kash.utils.common.import_utils import Tallies, import_subdirs
+from kash.utils.common.import_utils import Tallies, import_recursive
 
 log = get_logger(__name__)
 
@@ -13,12 +13,12 @@ log = get_logger(__name__)
 def import_and_register(
     package_name: str | None,
     parent_dir: Path,
-    subdir_names: list[str] | None = None,
+    resource_names: list[str] | None = None,
     tallies: Tallies | None = None,
 ):
     """
     This hook can be used for auto-registering commands and actions from any
-    subdirectory of a given package.
+    module or subdirectory of a given package.
 
     Useful to call from `__init__.py` files to import a directory of code,
     auto-registering annotated commands and actions and also handles refreshing the
@@ -38,7 +38,7 @@ def import_and_register(
         prev_command_count = len(get_all_commands())
         prev_action_count = len(ac)
 
-        import_subdirs(package_name, parent_dir, subdir_names, tallies)
+        import_recursive(package_name, parent_dir, resource_names, tallies)
 
         new_command_count = len(get_all_commands()) - prev_command_count
         new_action_count = len(ac) - prev_action_count

kash/exec/llm_transforms.py

@@ -13,9 +13,9 @@ 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
-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
+from kash.utils.text_handling.doc_normalization import normalize_formatting
 
 log = get_logger(__name__)